WebSVN – eFlore/Applications.cel – Path Comparison – /

Ignore whitespace Rev 3944 → Rev 3943

 /trunk/src/org/tela_botanica/client/interfaces/Rafraichissable.java
 New file
 ,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);
+}

 /trunk/src/org/tela_botanica/client/interfaces/ListePaginable.java
 New file
 ,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

 /trunk/src/org/tela_botanica/client/interfaces/Filtrable.java
 New file
 ,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();
+}

 /trunk/src/org/tela_botanica/client/interfaces/FournisseurListe.java
 New file
 ,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

 /trunk/src/org/tela_botanica/client/interfaces/IdVue.java
 New file
 ,0 → 1,95
+package org.tela_botanica.client.interfaces;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("identification"));
+                iMediateur = im;
+                champId = new TextField();
+                ok = new Button(Msg.get("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) {
+        }
+}

 /trunk/src/org/tela_botanica/client/interfaces/VueListable.java
 New file
 ,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();
+}

 /trunk/src/org/tela_botanica/client/CarnetEnLigneModele.java
 New file
 ,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).connecterUtilisateur(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);
+        }
+}

 /trunk/src/org/tela_botanica/client/cel2.java
 New file
 ,0 → 1,110
+package org.tela_botanica.client;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.util.Util;
+import org.tela_botanica.client.util.Analytics;
+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.dom.client.Element;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Timer;
+import com.google.gwt.user.client.Window.Location;
+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(null);
+                GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
+                        @Override
+                        public void onUncaughtException(Throwable e) {
+                                        Window.alert("uncaught: " + e.getMessage());
+                                        String s = buildStackTrace(e, "RuntimeException:\n");
+                                        Window.alert(s);
+                                        e.printStackTrace();
+                        }
+                });
+                */
+                // TODO: config devrait être un singleton
+                Configuration config = new Configuration();
+                initialiserLangue();
+                // stats
+                Analytics.pageVisitee();
+                Element elem = DOM.getElementById("texte_chargement");
+                elem.setInnerText(Msg.get("chargement"));
+                // Chargement de l'api google maps v3 avant l'initialisation pour
+                // éviter des "complications"
+                // TODO: fabriquer une classe qui cherche dans la config une liste d'api
+                // à charger, les instancie et ensuite lance l'application
+                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(1500);
+        }
+        private void initialiserLangue() {
+                // Si la langue est précisée dans l'url on la prend,
+                // Sinon on tente de prendre celle du systeme si elle est supportée
+                // Sinon on prend celle par défaut
+                // @TODO: avertissement si la langue indiquée dans l'url n'est pas la bonne
+                String langueURL = Location.getParameter("lang");
+                String langueSysteme = Util.obtenirCodeLangueSysteme();
+                if (! Msg.init()) {
+                        Util.LogVersFirebug("La langue par défaut \"" + Msg.getLangueDefaut() + "\" n'a pas pu être chargée");
+                }
+                if(langueSysteme != null && !langueSysteme.equals("")) {
+                        if(Msg.langueEstDisponible(langueSysteme)) {
+                                Msg.setLangue(langueSysteme);
+                        }
+                }
+                if (langueURL != null && ! langueURL.equals("")) {
+                        Util.LogVersFirebug("Langue passée dans l'URL: " + langueURL);
+                        if (! Msg.setLangue(langueURL)) {
+                                Util.LogVersFirebug("La langue demandée \"" + langueURL + "\" n'a pas pu être chargée");
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeEntiteGeographiqueObservationAsynchroneDAO.java
 New file
 ,0 → 1,103
+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 localites.
+ * @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;
+        }
+        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");
+                                                                String pays  = Util.getValeurJsonOuVide(entites, "pays");
+                                                                EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(idZoneGeo, zoneGeo, lieuDit, station);
+                                                                ent.setPays(pays);
+                                                                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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ImageGeneriqueVueAsynchroneDAO.java
 New file
 ,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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/InformationLocaliteDAO.java
 New file
 ,0 → 1,201
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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 InformationLocaliteDAO {
+        private final String NOM_SERVICE = "CoordSearch";
+        private final String CODE_PAYS = "FR";
+        // Ce DAO peut être fréquemment sollicité lors de l'utilisation de la carte
+        // et peut empiler beaucoup de longues requête, ceci permet donc de les annuler facilement
+        private static Request requeteEnCours = null;
+        Rafraichissable r = null;
+        public InformationLocaliteDAO(Rafraichissable r) {
+                this.r = r;
+        }
+        public void obtenirLocalitePlusProche(final Rafraichissable r, final double lng,
+                        final double lat) {
+                annulerRequeteEnCours();
+                String adresseAppel = Configuration.getServiceBaseUrl() + "/"
+                                + NOM_SERVICE + "?lat="+URL.encode("" + lat) + "&lon="+URL.encode("" + lng);
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel);
+                try {
+                        requeteEnCours = rb.sendRequest(null, new RequestCallback() {
+                                @Override
+                                public void onError(Request request, Throwable exception) {
+                                        Window.alert(exception.getMessage());
+                                        requeteEnCours = null;
+                                }
+                                @Override
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        EntiteGeographiqueObservation infos;
+                                        String idLocalite = "";
+                                        String nomLocalite = "";
+                                        String pays = "";
+                                        if (response.getStatusCode() == Response.SC_BAD_REQUEST) {
+                                                Window.alert(Msg.get("requete-mal-formee"));
+                                        } else {
+                                                if(response.getText().equals("")) {
+                                                        infos = new EntiteGeographiqueObservation(idLocalite, nomLocalite, 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) {
+                                                                nomLocalite = objectRetour.get("nom").isString().stringValue();
+                                                        }
+                                                        if(objectRetour.get("code_zone").isString() != null) {
+                                                                idLocalite = objectRetour.get("code_zone").isString().stringValue().substring(0, 2);
+                                                        }
+                                                        if(objectRetour.get("code_pays").isString() != null) {
+                                                                pays = objectRetour.get("code_pays").isString().stringValue();
+                                                        }
+                                                }
+                                        }
+                                        infos = new EntiteGeographiqueObservation(idLocalite, nomLocalite, null, null);
+                                        infos.setLat(""+lat);
+                                        infos.setLon(""+lng);
+                                        infos.setPays(pays);
+                                        r.rafraichir(infos, false);
+                                }
+                        });
+                } catch (RequestException e) {
+                        Window.alert(e.getMessage());
+                }
+        }
+        public void obtenirInfosLocalite(final Rafraichissable r,
+                        String valeurLocalite, String codeLoc) {
+                annulerRequeteEnCours();
+                codeLoc = codeLoc.replaceAll("000null", "*");
+                codeLoc = codeLoc.replaceAll("\"", "");
+                valeurLocalite = valeurLocalite.split(" \\([0-9][0-9]\\)")[0];
+                valeurLocalite = valeurLocalite.replaceAll("000null", "*");
+                valeurLocalite = valeurLocalite.replaceAll("\"", "");
+                String adresseAppel = Configuration.getServiceBaseUrl() + "/"
+                                + NOM_SERVICE+"?zone="+ URL.encode(valeurLocalite);
+                if(!codeLoc.trim().isEmpty()) {
+                        // Cas du code de département ou postal
+                        if(Util.estUnDepartement(codeLoc)) {
+                                adresseAppel += "&code="+URL.encode(codeLoc)+"&pays="+URL.encode(CODE_PAYS);
+                        } else {
+                                //cas du code pays
+                                adresseAppel += "&pays="+URL.encode(codeLoc);
+                        }
+                }
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel);
+                try {
+                        requeteEnCours = 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(Msg.get("impossible-geolocaliser-obs"), 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 nomLocalite = Util.getValeurJsonOuVide(objectRetour, "nom");
+                                                        String idLocalite = Util.getValeurJsonOuVide(objectRetour, "code_zone");
+                                                        lat = Util.jsonNonNull(objectRetour,"lat") ? objectRetour.get("lat").isNumber().doubleValue(): 0.0;
+                                                        lng = Util.jsonNonNull(objectRetour,"lng") ? objectRetour.get("lng").isNumber().doubleValue(): 0.0;
+                                                        String pays = Util.getValeurJsonOuVide(objectRetour, "code_pays");
+                                                        infos = new EntiteGeographiqueObservation(idLocalite, nomLocalite, null, null);
+                                                        infos.setLat(""+lat);
+                                                        infos.setLon(""+lng);
+                                                        infos.setPays(pays);
+                                                        r.rafraichir(infos, false);
+                                                } else {
+                                                        EntiteGeographiqueObservation infos;
+                                                        String idLocalite = "";
+                                                        String nomLocalite = "";
+                                                        infos = new EntiteGeographiqueObservation(idLocalite, nomLocalite, null, null);
+                                                        infos.setLat("");
+                                                        infos.setLon("");
+                                                        r.rafraichir(infos, false);
+                                                }
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        Window.alert(e.getMessage());
+                }
+        }
+        public static void annulerRequeteEnCours() {
+                if(requeteEnCours != null) {
+                        requeteEnCours.cancel();
+                        requeteEnCours = null;
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ImageInformationRepartitionAsynchroneDAO.java
 New file
 ,0 → 1,124
+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.core.client.Callback;
+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 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();
+                }
+        }
+        public static void taxonEstPresentDansZoneGeo(String referentielTaxo, String numeroNomenclaturalSaisiObservation, String pays, String zoneGeo, final Callback<String, String> callback) {
+                String referentielDefaut =  Configuration.getReferentielsDispos().get(0).getCode();
+                referentielTaxo = (referentielTaxo != null && !referentielTaxo.isEmpty()) ? referentielTaxo : referentielDefaut;
+                String url = Configuration.getServiceBaseUrl()+"/InventoryTaxonPresent/"+referentielTaxo+"/"+numeroNomenclaturalSaisiObservation+"?pays="+URL.encode(pays)+"&ce_zone_geo="+URL.encode(zoneGeo);
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, url) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                @Override
+                                public void onError(Request request, Throwable exception) {
+                                        callback.onFailure(exception.getMessage());
+                                }
+                                @Override
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        final JSONValue responseValue = JSONParser
+                                                        .parse(response.getText());
+                                        if (responseValue.isString() != null) {
+                                                //Window.alert(response.getText()+responseValue.isString().stringValue());
+                                                callback.onSuccess(responseValue.isString().stringValue());
+                                        } else {
+                                                callback.onFailure(response.getText());
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        callback.onFailure(e.getMessage());
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/UtilisateurAsynchroneDAO.java
 New file
 ,0 → 1,262
+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.i18n.Msg;
+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 org.tela_botanica.client.util.Util;
+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.JSONString;
+import com.google.gwt.json.client.JSONValue;
+import com.google.gwt.user.client.Timer;
+import com.google.gwt.user.client.Window;
+public class UtilisateurAsynchroneDAO {
+        /**
+         * Le modèle associé au DAO
+         */
+        private CarnetEnLigneModele carnetEnLigneModele = null ;
+        private Timer rafraichisseurJeton;
+        /**
+         * 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) {
+                String url = Configuration.getIdentificationBaseUrl()+"/identite/";
+                // Recherche identifiant utilisateur identifie
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, url, false) ;
+                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(Msg.get("erreur-contacter-serveur"));
+                                        } else {
+                                                JSONValue jsonValue = JSONParser.parse(response.getText());
+                                                JSONObject objetJsonUtilisateur = jsonValue.isObject();
+                                                if (objetJsonUtilisateur != null && objetJsonUtilisateur.get("session") != null) {
+                                                        // Drapeau leve si utilisateur deja identifie
+                                                        boolean identifie = objetJsonUtilisateur.get("session").isBoolean().booleanValue();
+                                                        if(identifie) {
+                                                                if(objetJsonUtilisateur.get("token").isString() != null) {
+                                                                        String token = ((JSONString) objetJsonUtilisateur.get("token")).stringValue();
+                                                                        Utilisateur.setJeton(token);
+                                                                        int dureeJeton = (int)objetJsonUtilisateur.get("duration").isNumber().doubleValue();
+                                                                        gererTimerRafraichissementJeton(dureeJeton, r);
+                                                                }
+                                                        }
+                                                }
+                                                // dans tous les cas même si l'on est pas identifié par le sso, ceci permet d'obtenir
+                                                // une session temporaire
+                                                obtenirInfosComplementairesUtilisateur(r);
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+        public void obtenirInfosComplementairesUtilisateur(final Rafraichissable r) {
+                String url = Configuration.getServiceBaseUrl()+"/User/";
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, url) ;
+                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(Msg.get("erreur-contacter-serveur"));
+                                        } else {
+                                                JSONValue jsonValue = JSONParser.parse(response.getText());
+                                                JSONObject objetJsonUtilisateur;
+                                                if ((objetJsonUtilisateur = jsonValue.isObject()) != null) {
+                                                                Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur);
+                                                                if(r != null) {
+                                                                        r.rafraichir(utilisateur,true);
+                                                                }
+                                                } else {
+                                                }
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+        public void deconnecterUtilisateur(final Rafraichissable r, String user) {
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getIdentificationBaseUrl()+ "/deconnexion/") ;
+                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) {
+                                        Utilisateur.setJeton("");
+                                        gererTimerRafraichissementJeton(0, r);
+                                        obtenirInfosComplementairesUtilisateur(r);
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+        public void connecterUtilisateur (final Rafraichissable r, String login, String password) {
+                //connexion?login=aurelien@tela-botanica.org&password=Canard123$
+                if(!login.isEmpty() && !password.isEmpty()) {
+                        String url = Configuration.getIdentificationBaseUrl() + "/connexion?login=" + URL.encodeComponent(login) + "&password=" + URL.encodeComponent(password);
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, url) ;
+                        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 = jsonValue.isObject();
+                                                if (objetJsonUtilisateur != null && objetJsonUtilisateur.get("session") != null) {
+                                                        if(objetJsonUtilisateur.get("token").isString() != null) {
+                                                                String token = ((JSONString) objetJsonUtilisateur.get("token")).stringValue();
+                                                                Utilisateur.setJeton(token);
+                                                                int dureeJeton = (int)objetJsonUtilisateur.get("duration").isNumber().doubleValue();
+                                                                gererTimerRafraichissementJeton(dureeJeton, r);
+                                                        }
+                                                        obtenirInfosComplementairesUtilisateur(r);
+                                                }
+                                        }
+                                }) ;
+                        } catch (RequestException e) {
+                                e.printStackTrace() ;
+                        }
+                }
+        }
+        private void gererTimerRafraichissementJeton(int duree, final Rafraichissable r) {
+                // Rafraîchissement automatique du jeton - s'annule lorsque le jeton devient nul
+                if (!Utilisateur.getJeton().isEmpty() && duree > 0) {
+                        if (rafraichisseurJeton == null) { // on sait jamais
+                                // 3/4 de la durée de vie du jeton, en millisecondes (ça laisse de la marge)
+                                int delaiRepetition = (duree * 1000) * 3 / 4;
+                                rafraichisseurJeton = new Timer() {
+                                        @Override
+                                        public void run() {
+                                                // Appel de l'annuaire pour rafraîchir le jeton (cb nul pour l'instant)
+                                                // @TODO gérer le possible changement de profil / coordonnées de l'utilisateur
+                                                // en cours de connexion
+                                                getEtatUtilisateur(r);
+                                        }
+                                };
+                                rafraichisseurJeton.scheduleRepeating(delaiRepetition);
+                        }
+                } else {
+                        if (rafraichisseurJeton != null) { // on sait jamais non plus
+                                rafraichisseurJeton.cancel();
+                                rafraichisseurJeton = null;
+                        }
+                }
+        }
+        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() ;
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeUtilisateurAsynchroneDAO.java
 New file
 ,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

 /trunk/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesImageAsynchroneDAO.java
 New file
 ,0 → 1,108
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("liaison-mots-cles-effectuee"));
+                                }
+                        }) ;
+                } 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(Msg.get("suppression-liaison-mot-cle-effectuee"));
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesObsAsynchroneDAO.java
 New file
 ,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) {
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/NomRetenuAsynchroneDAO.java
 New file
 ,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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ImageUploaderAsynchroneDAO.java
 New file
 ,0 → 1,168
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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() {
+                // Ce composant est moche, compliqué et pas pratique pour l'i18n
+                // TODO: trouver un remplacer comme https://code.google.com/p/gwtupload/
+                UploadDialog up = new UploadDialog(Msg.get("upload-simple-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(Msg.get("upload-multiple-fichiers"));
+                nPan.setWidth(640);
+                final String warning = "<p class=\"warning_upload\"> "+Msg.get("indication-fin-upload-multiple-fermer")+". </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 paramLangue = "<param name=\"lang\" value=\""+Msg.getLangue()+"\">";
+                final String paramFormdata = "<param name=\"formData\" value=\"postid\">";
+                final String finApplet = "</applet>";
+                final String appelApplet = applet + paramPostTarget + paramUploadPolicy
+                                + paramMaxChunkSize + paramMaxFileSize + paramTransmitMetaData
+                                + paramFilesPerRequest + paramAllowedExtensions + paramLangue
+                                + 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()() ;
+          }
+        }-*/;
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielPersoAsynchroneDAO.java
 New file
 ,0 → 1,36
+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.Utilisateur;
+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 {
+        public static String getUrlReferentielPerso(TypesReferentiels refDemande) {
+                return Configuration.getServiceBaseUrl() +
+                                "/SelfRefList/"+
+                                "{utilisateur}/"+
+                                refDemande.toString()+
+                                "?start=0&limit=50&recherche=";
+        }
+        public static String formaterUrlRequeteAutoCompletionPerso(String urlRequete, String valeur) {
+                return urlRequete.replace("{utilisateur}", Utilisateur.getInstance().getIdentifiantUtilisateurConsulte())+URL.encodeQueryString(valeur);
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielNomAsynchroneDAO.java
 New file
 ,0 → 1,50
+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.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 {
+        public static String getBaseUrlReferentielNom() {
+                return Configuration.getServiceBaseUrl()+"/NameSearch/{referentiel}/";
+        }
+        public static String formaterUrlAutoCompletionReferentielNom(String urlRequete, String referentiel, String critere) {
+                 // On vérifie si un genre et une espèce sont demandées
+                // et ajoute le / manuellement car sinon il devient urlencodé
+                String[] criteres =critere.split("/");
+                urlRequete = urlRequete.replace("{referentiel}", referentiel);
+                String params = "";
+            if(criteres.length > 1) {
+                String critere1 = criteres[0];
+                String critere2 = criteres[1];
+                params += URL.encode(critere1)+"/"+URL.encode(critere2);
+            } else {
+                params += URL.encode(critere);
+            }
+            return urlRequete+params;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeDateImageAsynchroneDAO.java
 New file
 ,0 → 1,71
+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;
+        }
+        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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ImageAsynchroneDAO.java
 New file
 ,0 → 1,182
+package org.tela_botanica.client.modeles.dao;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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) {
+                                        // Attention "OK" n'est pas un terme à traduire ici
+                                        if (response.getText().equals("OK")) {
+                                                return;
+                                        } else {
+                                                com.google.gwt.user.client.Window.alert(Msg.get("probleme-mise-a-jour-donnees"));
+                                        }
+                                }
+                        });
+                } 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
+                                        // Attention OK n'est pas un terme à traduire ici
+                                        if (response.getText().equals("OK")) {
+                                                com.google.gwt.user.client.Window
+                                                .alert(Msg.get("mots-cles-appliques")+" : "+iModele.renvoyerChaineMotClesTexte(ic));
+                                                return;
+                                        } else {
+                                                com.google.gwt.user.client.Window
+                                                                .alert(Msg.get("probleme-mise-a-jour-donnees")+", "+Msg.get("serveur-a-repondu")+" "+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(Msg.get("probleme-mise-a-jour-donnees")+" : "+response.getText());
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielLocaliteAsynchroneDAO.java
 New file
 ,0 → 1,32
+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.ReferentielLocalite;
+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 localites. Utilisation d'un cache pour eviter les requetes inutiles
+ * @author David Delon
+ *
+ */
+public class ListeReferentielLocaliteAsynchroneDAO {
+        public static String getUrlReferentielLocalites() {
+                return Configuration.getServiceBaseUrl()+"/LocationSearch/";
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeImageAsynchroneDAO.java
 New file
 ,0 → 1,252
+package org.tela_botanica.client.modeles.dao;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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) {
+                                                // Attention OK n'est pas un terme à traduire ici
+                                                if (response.getText().equals("OK")) {
+                                                        return;
+                                                } else {
+                                                        com.google.gwt.user.client.Window
+                                                                        .alert(Msg.get("probleme-mise-a-jour-donnees"));
+                                                }
+                                        }
+                                });
+                        } 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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/NombreImageAsynchroneDAO.java
 New file
 ,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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ImportObservationAsynchroneDAO.java
 New file
 ,0 → 1,58
+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) {
+                                        // Attention OK n'est pas un terme à traduire ici
+                                        if(response.getText().equals("OK")) {
+                                                oModele.obtenirNombreObservation(null);
+                                        }
+                                        else
+                                        {
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ExportObservationsDAO.java
 New file
 ,0 → 1,46
+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 org.tela_botanica.client.util.Util;
+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;
+                // jeton SSO en GET car pas moyen d'ajouter un header Authorization
+                requete += "&Authorization=" + Utilisateur.getJeton();
+                String url = Configuration.getServiceBaseUrl()+"/CelWidgetExport/export/?"+requete;
+                //Util.LogVersFirebug(url);
+                Window.open(url ,"Export",null) ;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/MotsClesAsynchroneDAO.java
 New file
 ,0 → 1,269
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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;
+import com.google.gwt.user.client.Window;
+/**
+ * DAO d'accès à l'arbre de mots clés
+ *
+ * @author aurelien
+ *
+ */
+public class MotsClesAsynchroneDAO {
+        private String identifiant = "" ;
+        private String mode = "";
+        private String nomService = "InventoryKeywordTree";
+        //private String nomService = "InventoryKeyWordList";
+        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()
+                                + "/"+nomService+"/"+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
+         * @param r
+         */
+        public void ajouterBaseDeDonnees(String motcle, final Rafraichissable r) {
+                if (!motcle.equals("")) {
+                        String postData = motcle+"&mode="+mode;
+                        // on fait un post asynchrone
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+                                        + "/"+nomService+"/");
+                        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 pas très malléable complique les choses
+                                                try {
+                                                        Integer idMotcle = Integer.parseInt(response.getText());
+                                                        r.rafraichir(idMotcle, false);
+                                                } catch (Exception e) {
+                                                        com.google.gwt.user.client.Window
+                                                        .alert(Msg.get("probleme-mise-a-jour-donnees")+", "+Msg.get("serveur-a-repondu")+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, final Rafraichissable r) {
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=DELETE";
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+                                        + "/"+nomService+"/"
+                                        + 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
+                                                // Attention OK n'est pas un terme à traduire ici
+                                                if (response.getText().equals("OK")) {
+                                                        com.google.gwt.user.client.Window.alert(Msg.get("mot-cle-supprime"));
+                                                        r.rafraichir(null, false);
+                                                        return;
+                                                } else {
+                                                        com.google.gwt.user.client.Window
+                                                                        .alert(Msg.get("probleme-mise-a-jour-donnees")+", "+Msg.get("serveur-a-repondu")+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, final Rafraichissable r) {
+                //TODO : cette fonction n'a aucun sens, on lui passe une sorte de chaine
+                // de requete url, elle devrait avoir au moins trois paramètres qu'elle assemble elle même
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=modification"+motcle;
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+                                        + "/"+nomService+"/"+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(Msg.get("mot-cle-renomme"));
+                                                        r.rafraichir(null, false);
+                                                        return;
+                                                } else {
+                                                        com.google.gwt.user.client.Window
+                                                                        .alert(Msg.get("probleme-mise-a-jour-donnees")+", "+Msg.get("serveur-a-repondu")+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, final Rafraichissable r) {
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=deplacement"+motcle;
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+                                        + "/"+nomService+"/"+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) {
+                                                r.rafraichir(null, false);
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/LienImageAsynchroneDAO.java
 New file
 ,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();
+                        }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeDateObservationAsynchroneDAO.java
 New file
 ,0 → 1,73
+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;
+        }
+        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();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ObservationAsynchroneDAO.java
 New file
 ,0 → 1,211
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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 org.tela_botanica.client.util.Analytics;
+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 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 une requete au serveur pour ajouter une observation
+         *
+         * @param motcle
+         *      le mot-clé à ajouter avec son parent et son identifiant
+         */
+        public void ajouter(final Rafraichissable r, final 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())
+                                +"&pays="+ (obs.getPays() != null ? obs.getPays() : "")
+                                +"&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.getCodeCourtReferentielTaxo())
+                                +"&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());
+                                                        }
+                                                        // stats
+                                                        Analytics.evenement("observation", "creation", "{\"utilisateur\": \"" + utilisateur + "\", \"nom_sci\": \"" + obs.getNomSaisi() + "\", \"referentiel\": \"" + obs.getCodeCourtReferentielTaxo() + "\"}");
+                                                        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, final 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())
+                                +"&pays="+ (obs.getPays() != null ? obs.getPays() : "")
+                                + "&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.getCodeCourtReferentielTaxo())
+                                +"&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());
+                                                        }
+                                                        // stats
+                                                        Analytics.evenement("observation", "modification", "{\"utilisateur\": \"" + utilisateur + "\", \"nom_sci\": \"" + obs.getNomSaisi() + "\", \"referentiel\": \"" + obs.getCodeCourtReferentielTaxo() + "\"}");
+                                                        r.rafraichir(obs,true);
+                                        }
+                                }) ;
+                        } catch (RequestException e) {
+                }
+        }
+        public void supprimer(Rafraichissable r, final String identifiant, final 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")) {
+                                                        // stats
+                                                        Analytics.evenement("observation", "suppression", "{\"utilisateur\": \"" + identifiant + "\", \"numero_ordre\": \"" + numeroOrdre + "\"}");
+                                        } else {
+                                                com.google.gwt.user.client.Window.alert(Msg.get("probleme-mise-a-jour-donnees"));
+                                                return ;
+                                        }
+                                }
+                        });
+                        r.rafraichir("OK", true) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeObservationAsynchroneDAO.java
 New file
 ,0 → 1,279
+package org.tela_botanica.client.modeles.dao;
+import org.tela_botanica.client.i18n.Msg;
+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 (localites , 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.getPays() != null) {
+                                postData += "&pays=" + URL.encodeComponent(obs.getPays());
+                        }
+                        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) {
+                                        // Attention OK n'est pas un terme à traduire ici
+                                        if (response.getText().equals("OK")) {
+                                        } else {
+                                                com.google.gwt.user.client.Window
+                                                                .alert(Msg.get("probleme-mise-a-jour-donnees"));
+                                                return ;
+                                        }
+                                }
+                        });
+                        // Attention OK n'est pas un terme à traduire ici non plus
+                        r.rafraichir("OK", true) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/NombreObservationAsynchroneDAO.java
 New file
 ,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) {
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/ListeReferentielChampsEtendusDAO.java
 New file
 ,0 → 1,304
+package org.tela_botanica.client.modeles.dao;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import org.tela_botanica.client.cel2;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.modeles.objets.ListeChampsEtendus;
+import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;
+import org.tela_botanica.client.modeles.objets.ListeReferentielPerso;
+import org.tela_botanica.client.observation.ObservationModele;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.http.client.Request;
+import org.tela_botanica.client.util.RequestBuilderWithCredentials;
+import org.tela_botanica.client.util.Util;
+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;
+import com.google.gwt.user.client.Window;
+public class ListeReferentielChampsEtendusDAO {
+        public static ListeGroupesChampsEtendus cacheGroupes;
+        public static HashMap<String, String> cacheClesLabels;
+        public static HashMap<String, String> cacheDescription = new HashMap<String, String>();
+        public static String prefixePageChampEtendu = "CE";
+        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) {
+                                        ListeChampsEtendus labelCles = new ListeChampsEtendus(response.getText());
+                                        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();
+                }
+        }
+        public void obtenirGroupesChampsEtendus(final Rafraichissable r) {
+                if(cacheGroupes == null) {
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
+                                        "/CatalogueChampsEtendus/groupes");
+                        try {
+                                rb.sendRequest(null, new RequestCallback() {
+                                @Override
+                                public void onResponseReceived(final Request request,
+                                final Response response) {
+                                        ListeGroupesChampsEtendus valeurs = new ListeGroupesChampsEtendus(response.getText());
+                                        cacheGroupes = valeurs;
+                                        r.rafraichir(valeurs, true);
+                                }
+                                @Override
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                        });
+                        } catch (RequestException e) {
+                                e.printStackTrace();
+                        }
+                } else {
+                        r.rafraichir(cacheGroupes, true);
+                }
+        }
+        public void obtenirCatalogueChampsEtendus(final Rafraichissable r) {
+                if(cacheClesLabels == null) {
+                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
+                                        "/CatalogueChampsEtendus/champs");
+                        try {
+                                rb.sendRequest(null, new RequestCallback() {
+                                @Override
+                                public void onResponseReceived(final Request request,
+                                final Response response) {
+                                        try {
+                                                JSONValue champsJson = JSONParser.parseStrict(response.getText());
+                                                JSONArray champs = champsJson.isArray();
+                                                cacheClesLabels = new HashMap<String, String>(champs.size());
+                                                for (int i = 0; i < champs.size(); i++) {
+                                                        JSONObject champ = champs.get(i).isObject();
+                                                        String cle = champ.get("cle").isString().stringValue();
+                                                        String label = champ.get("label").isString().stringValue();
+                                                        cacheClesLabels.put(cle, label);
+                                                        r.rafraichir(cacheClesLabels, true);
+                                                }
+                                        } catch (Exception e) {
+                                                // TODO: handle exception
+                                        }
+                                }
+                                @Override
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                        });
+                        } catch (RequestException e) {
+                                e.printStackTrace();
+                        }
+                } else {
+                        r.rafraichir(cacheClesLabels, true);
+                }
+        }
+        public static void telechargerDescriptionWikini(final String champ, final Callback<String, String> callback) {
+                String url = Configuration.getWikiDescriptionChampsEtendusRestUrl()+obtenirNomPageChampEtendu(champ)+"?";
+                String options = Configuration.getWikiDescriptionChampsEtendusUrlOptions();
+                if(cacheDescription.containsKey(champ)) {
+                        callback.onSuccess(cacheDescription.get(champ));
+                }
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,
+                                url + options);
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                @Override
+                                public void onResponseReceived(final Request request,
+                                                final Response response) {
+                                        try {
+                                                final JSONValue responseValue = JSONParser.parse(response.getText());
+                                                String description = "";
+                                                JSONObject reponse = responseValue.isObject();
+                                                if(reponse != null && reponse.get("texte") != null && reponse.get("texte").isString() != null) {
+                                                        description = reponse.get("texte").isString().stringValue();
+                                                }
+                                                cacheDescription.put(champ, description);
+                                                callback.onSuccess(description);
+                                        } catch(Exception exception) {
+                                                this.onError(request, exception);
+                                        }
+                                }
+                                @Override
+                                public void onError(Request request, Throwable exception) {
+                                        cacheDescription.put(champ, "");
+                                        callback.onFailure("");
+                                }
+                        });
+                } catch (RequestException e) {
+                        e.printStackTrace();
+                }
+        }
+        // Pour obliger la page wiki a avoir été créée avant de rediriger, on utilise une requete synchrone
+        private static native String effectuerRequeteSynchrone(String url, String contenu, String typeRequete)/*-{
+                // tant pis pour les vieux navigateurs, ie6 etc...
+                // tous ceux que l'on supporte connaissent XMLHttpRequest
+        var xhReq = new XMLHttpRequest();
+        xhReq.open(typeRequete, url, false);
+        if(typeRequete == "POST") xhReq.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
+        xhReq.send(contenu);
+        var serverResponse = xhReq.status + xhReq.responseText;
+        return serverResponse;
+        }-*/;
+        public static void creerPageWikini(final String cle) {
+                String url = Configuration.getWikiDescriptionChampsEtendusRestUrl()+obtenirNomPageChampEtendu(cle)+"?";
+                String options = Configuration.getWikiDescriptionChampsEtendusUrlOptions();
+                String pageTpl = Configuration.getWikiDescriptionChampsEtendusUrlOptionsPageTpl();
+                effectuerRequeteSynchrone(url + options + pageTpl, "", "GET");
+        }
+        public static String obtenirUrlEditionDescriptionWiki(String cle) {
+                String url = Configuration.getWikiDescriptionChampsEtendusPageUrl()+obtenirNomPageChampEtendu(cle)+"/edit";
+                return url;
+        }
+        protected static String obtenirNomPageChampEtendu(String cle) {
+                return prefixePageChampEtendu+Util.convertirEnChaMot(cle);
+        }
+        public static String getUrlRequeteValeursChampEtendu(String cle) {
+                return Configuration.getServiceBaseUrl() +
+                "/NomsChampsEtendus/valeur"+
+                "?cle="+URL.encode(cle)+"&recherche=";
+        }
+        public static String getUrlRequeteNomsChampsEtendus() {
+                return Configuration.getServiceBaseUrl()+
+                           "/NomsChampsEtendus/cle?recherche=";
+        }
+        public static Map<String, String> parserRetourListeValeursChampsEtendus(Response response) {
+                Map<String, String> valeurs = new HashMap<String, 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.put(reponse.get(i).isString().stringValue(), reponse.get(i).isString().stringValue());
+                        }
+                }
+                return valeurs;
+        }
+        public static Map<String, String> parserRetourListeNomsChampsEtendus(Response response) {
+                final JSONValue responseValue = JSONParser.parse(response.getText());
+                JSONObject reponse = null;
+                cacheClesLabels = new HashMap<String, String>();
+                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();
+                                cacheClesLabels.put(cle, valeur);
+                        }
+                }
+                return cacheClesLabels;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/dao/TransmissionObservationAsynchroneDAO.java
 New file
 ,0 → 1,74
+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 org.tela_botanica.client.util.Analytics;
+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, final String identifiant, final String idsObs, final 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) {
+                                        // stats
+                                        String action = "";
+                                        if (publier) {
+                                                action = "rendre-publiques";
+                                        } else {
+                                                action = "rendre-privees";
+                                        }
+                                        Analytics.evenement("observation", action, "{\"utilisateur\": \"" + identifiant + "\", \"observations\": \"" + idsObs + "\"}");
+                                        // Attention OK n'est pas un terme à traduire ici
+                                        r.rafraichir("OK",true);
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/DateObservation.java
 New file
 ,0 → 1,33
+package org.tela_botanica.client.modeles.objets;
+public class DateObservation {
+        private String annee=null;
+        private String mois=null;
+        private String jour=null;
+        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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/Observation.java
 New file
 ,0 → 1,402
+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 String pays=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, String pays) {
+                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.pays = Util.getValeurJsonOuVide(observation, "pays");
+                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 getPays() {
+                return pays;
+        }
+        public void setPays(String pays) {
+                this.pays = pays;
+        }
+        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() >= 3) {
+                        int positionDeuxPoints = referentielTaxo.indexOf(':');
+                        if (positionDeuxPoints == -1) {
+                                codeRef = referentielTaxo;
+                        } else {
+                                codeRef = referentielTaxo.substring(0, positionDeuxPoints);
+                        }
+                }
+                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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeObservation.java
 New file
 ,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);
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ChampEtendu.java
 New file
 ,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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeChampsEtendus.java
 New file
 ,0 → 1,30
+package org.tela_botanica.client.modeles.objets;
+import java.util.HashMap;
+import java.util.Iterator;
+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 ListeChampsEtendus extends HashMap<String, String> {
+        public ListeChampsEtendus(String listeChampsEtendusJson) {
+                super();
+                final JSONValue responseValue = JSONParser.parse(listeChampsEtendusJson);
+                JSONObject reponse = null;
+                // si c'est un objet
+                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();
+                                this.put(cle, valeur);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/EntiteGeographiqueObservation.java
 New file
 ,0 → 1,89
+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;
+        private String pays=null;
+        private int zoom = 0; // si zoom <= 0, on l'ignore lors du rafraîchissement
+        public EntiteGeographiqueObservation() {
+        }
+        /**
+         * @param zoneGeo
+         * @param departement
+         */
+        public EntiteGeographiqueObservation(String idZoneGeo, String zoneGeo, String lieuDit, String station, int zoom) {
+                this(idZoneGeo, zoneGeo, lieuDit, station);
+                this.zoom = zoom;
+        }
+        public EntiteGeographiqueObservation(String idZoneGeo, String zoneGeo, String lieuDit, String station) {
+                this.idZoneGeo = idZoneGeo;
+                this.zoneGeo = zoneGeo;
+                this.lieuDit = lieuDit;
+                this.station = station;
+        }
+        public void setPays(String pays) {
+                this.pays = pays;
+        }
+        public String getPays() {
+                return pays;
+        }
+        public void setLat(String la) {
+                lat = la;
+        }
+        public void setLon(String lo) {
+                lon = lo;
+        }
+        public void setZoom(int zoom) {
+                this.zoom = zoom;
+        }
+        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;
+        }
+        public int getZoom() {
+                return zoom;
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeEntiteGeographiqueObservation.java
 New file
 ,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);
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/Configuration.java
 New file
 ,0 → 1,340
+package org.tela_botanica.client.modeles.objets;
+import java.util.ArrayList;
+import java.util.List;
+import com.google.gwt.i18n.client.Dictionary;
+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 identificationBaseUrl;
+        private static String serviceBaseUrl;
+        private static String imageBaseUrl;
+        private static String suiviBugUrl ;
+        private static String aideBaseUrl ;
+        private static String remarquesBaseUrl ;
+        private static String serviceContact;
+        private static String referentielGeo ;
+        private static String cleGoogleMaps ;
+        private static String lienEfloreBaseUrl;
+        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 String activerSaisieChampsEtendus = "0";
+        private static String wikiDescriptionChampsEtendusPageUrl = "";
+        private static String wikiDescriptionChampsEtendusRestUrl = "";
+        private static String wikiDescriptionChampsEtendusRestUrlOptions = "";
+        private static String wikiDescriptionChampsEtendusUrlOptionsPageTpl = "";
+        private static String langueDefaut = "";
+        private static String languesDisponibles = "";
+        private static String chorologieAvertissementCourriel = "";
+        private static boolean prod = false;
+        /**
+         * Constructeur sans argument
+         */
+        public Configuration() {
+                // on utilise le dictionnaire d'internationalisation pour lire les
+                // variables du fichier javascript
+                //if(GWT.isScript()) {
+                        identificationBaseUrl = Dictionary.getDictionary("configuration").get(
+                                "identificationBaseUrl");
+                        serviceBaseUrl = Dictionary.getDictionary("configuration").get(
+                                        "serviceBaseUrl");
+                        serviceContact = Dictionary.getDictionary("configuration").get(
+                        "serviceContact");
+                        suiviBugUrl = Dictionary.getDictionary("configuration").get(
+                        "suiviBugUrl");
+                        imageBaseUrl = Dictionary.getDictionary("configuration").get(
+                        "imageBaseUrl");
+                        aideBaseUrl = Dictionary.getDictionary("configuration").get(
+                        "aideBaseUrl");
+                        remarquesBaseUrl = Dictionary.getDictionary("configuration").get(
+                        "remarquesBaseUrl");
+                        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");
+                        wikiDescriptionChampsEtendusPageUrl = Dictionary.getDictionary("configuration").get(
+                        "wikiDescriptionChampsEtendusPageUrl");
+                        wikiDescriptionChampsEtendusRestUrl = Dictionary.getDictionary("configuration").get(
+                        "wikiDescriptionChampsEtendusRestUrl");
+                        wikiDescriptionChampsEtendusRestUrlOptions = Dictionary.getDictionary("configuration").get(
+                        "wikiDescriptionChampsEtendusRestUrlOptions");
+                        wikiDescriptionChampsEtendusUrlOptionsPageTpl = Dictionary.getDictionary("configuration").get(
+                        "wikiDescriptionChampsEtendusUrlOptionsPageTpl");
+                        langueDefaut = Dictionary.getDictionary("configuration").get("langueDefaut");
+                        languesDisponibles = Dictionary.getDictionary("configuration").get("languesDisponibles");
+                        chorologieAvertissementCourriel = Dictionary.getDictionary("configuration").get("chorologieAvertissementCourriel");
+                        prod = Boolean.parseBoolean(Dictionary.getDictionary("configuration").get("prod"));
+                        // 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";
+                                }
+                        }
+        }
+        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 d'identification
+         *
+         * @return une url de la forme http://emplacement_serveur/annuaire/Auth
+         */
+        public static String getIdentificationBaseUrl() {
+                return identificationBaseUrl;
+        }
+        /**
+         * 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'url de base du widget de remarques
+         *
+         * @return une url pointant vers la racine du widget (sans paramètres)
+         */
+        public static String getRemarquesBaseUrl() {
+                return remarquesBaseUrl;
+        }
+        /**
+         * Accesseur pour le service de contact du carnet en ligne
+         *
+         * @return une chaine contenant le service de contact
+         */
+        public static String getServiceContact() {
+                return serviceContact;
+        }
+        /**
+         * 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 String getWikiDescriptionChampsEtendusPageUrl() {
+                return wikiDescriptionChampsEtendusPageUrl;
+        }
+        public static String getWikiDescriptionChampsEtendusRestUrl() {
+                return wikiDescriptionChampsEtendusRestUrl;
+        }
+        public static String getWikiDescriptionChampsEtendusUrlOptions() {
+                return wikiDescriptionChampsEtendusRestUrlOptions;
+        }
+        public static String getWikiDescriptionChampsEtendusUrlOptionsPageTpl() {
+                return wikiDescriptionChampsEtendusUrlOptionsPageTpl;
+        }
+        public static String getLangueDefaut() {
+                return langueDefaut;
+        }
+        public static String getLanguesDisponibles() {
+                return languesDisponibles;
+        }
+        public static String getChorologieAvertissementCourriel() {
+                return chorologieAvertissementCourriel;
+        }
+        public static boolean isProd() {
+                return prod;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeGroupesChampsEtendus.java
 New file
 ,0 → 1,59
+package org.tela_botanica.client.modeles.objets;
+import java.util.HashMap;
+import java.util.Iterator;
+import org.tela_botanica.client.cel2;
+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 ListeGroupesChampsEtendus extends HashMap<String,HashMap<String, String>> {
+        public HashMap<String, String> correspondancesClesLabels ;
+        public HashMap<String, String> correspondancesCorrespondancesIdsNomsGroupes;
+        public ListeGroupesChampsEtendus(String groupeChampsEtendusJson) {
+                super();
+                try {
+                        correspondancesClesLabels = new HashMap<String, String>();
+                        correspondancesCorrespondancesIdsNomsGroupes = new HashMap<String, String>();
+                        JSONValue groupesJson = JSONParser.parseStrict(groupeChampsEtendusJson);
+                        JSONArray groupes = groupesJson.isArray();
+                        for (int i = 0; i < groupes.size(); i++) {
+                                JSONObject groupe = groupes.get(i).isObject();
+                                String cleGroupe = groupe.get("cle").isString().stringValue();
+                                String nomGroupe = groupe.get("nom").isString().stringValue();
+                                JSONArray listeClesLabels = groupe.get("champs").isArray();
+                                correspondancesCorrespondancesIdsNomsGroupes.put(cleGroupe, nomGroupe);
+                                HashMap<String, String> groupesClesLabel = new HashMap<String, String>();
+                                for (int j = 0; j < listeClesLabels.size(); j++) {
+                                        JSONObject champ = listeClesLabels.get(j).isObject();
+                                        String cle = champ.get("cle").isString().stringValue();
+                                        String label = champ.get("label").isString().stringValue();
+                                        groupesClesLabel.put(cle, label);
+                                        correspondancesClesLabels.put(cle, label);
+                                }
+                                this.put(nomGroupe, groupesClesLabel);
+                        }
+                } catch (Exception e) {
+                        // TODO: handle exception
+                }
+        }
+        public HashMap<String, String> getCorrespondancesClesLabel() {
+                return correspondancesClesLabels;
+        }
+        public HashMap<String, String> getCorrespondancesCorrespondancesIdsNomsGroupes() {
+                return correspondancesCorrespondancesIdsNomsGroupes;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/Utilisateur.java
 New file
 ,0 → 1,140
+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;
+        // Jeton encodé en base64 passé de manière automatique aux services dans un header
+        private static String jeton = "";
+        public static Utilisateur InitialiserInstance(JSONObject objetJsonUtilisateur) {
+                thisUtilisateur = new Utilisateur(objetJsonUtilisateur);
+                return thisUtilisateur;
+        }
+        public static Utilisateur getInstance() {
+                return thisUtilisateur;
+        }
+        public static String getJeton() {
+                return jeton;
+        }
+        public static void setJeton(String jeton) {
+                Utilisateur.jeton = jeton;
+        }
+        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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/InfosReferentielNom.java
 New file
 ,0 → 1,67
+package org.tela_botanica.client.modeles.objets;
+import org.tela_botanica.client.i18n.Msg;
+public class InfosReferentielNom {
+        private String code = null;
+        private String version = null;
+        private String versionCourte = null;
+        private String intitule = null;
+        public InfosReferentielNom(String infosReferentiel) {
+                String[] codeVersion = infosReferentiel.split(":");
+                code = codeVersion[0];
+                intitule = Msg.get("referentiel-"+code);
+                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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ReferentielNom.java
 New file
 ,0 → 1,49
+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;
+        }
+        public boolean estRetenu() {
+                return statut != null && statut.equals("3");
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeDate.java
 New file
 ,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);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeReferentielPerso.java
 New file
 ,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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ImageCarnet.java
 New file
 ,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;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ListeImageCarnet.java
 New file
 ,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]);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/objets/ReferentielLocalite.java
 New file
 ,0 → 1,41
+package org.tela_botanica.client.modeles.objets;
+/**
+ *
+ * Classe representant un element du referentiel de localites
+ *
+ */
+public class ReferentielLocalite {
+        private String localite = null;
+        private String codeLocalite = null;
+        private String codeInsee = null;
+        /**
+         * @param localite
+         * @param code
+         */
+        public ReferentielLocalite(String localite, String code) {
+                this.localite = localite;
+                if(code.length() == 5) {
+                        codeInsee = code;
+                        codeLocalite = code.substring(0,2);
+                } else {
+                        codeLocalite = code;
+                }
+        }
+        public String getLocalite() {
+                return localite;
+        }
+        public String getCodeLocalite() {
+                return codeLocalite;
+        }
+        public String getCodeInsee() {
+                return codeInsee;
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/modeles/objets/Ontologies.java
 New file
 ,0 → 1,166
+package org.tela_botanica.client.modeles.objets;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import org.tela_botanica.client.i18n.Msg;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.IntegerFieldDef;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.SimpleStore;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+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 = {{Msg.get("certain"),"certain"},
+                                {Msg.get("douteux"),"douteux"},
+                                {Msg.get("a-determiner"),"aDeterminer"}
+                        };
+                SimpleStore storeCertitude = new SimpleStore(new String[] {"label","valeur"},valeurs);
+                storeCertitude.load();
+                return storeCertitude;
+        }
+        public static Store getValeursAbondance() {
+                Object[][] valeurs = {
+                        {Msg.get("abondance-5"),"5"},
+                        {Msg.get("abondance-4"),"4"},
+                        {Msg.get("abondance-3"),"3"},
+                        {Msg.get("abondance-2"),"2"},
+                        {Msg.get("abondance-1"),"1"},
+                        {Msg.get("abondance-+"),"+"},
+                        {Msg.get("abondance-r"),"r"},
+                        {Msg.get("abondance-i"),"i"},
+                        {Msg.get("abondance-1-5"),"1-5"},
+                        {Msg.get("abondance-5-10"),"5-10"},
+                        {Msg.get("abondance-10-50"),"10-50"},
+                        {Msg.get("abondance-50-100"),"50-100"},
+                        {Msg.get("abondance-100-500"),"100-500"},
+                        {Msg.get("abondance->500"),">500"},
+                        {Msg.get("abondance-E"),"E"},
+                        {Msg.get("abondance-RR"),"RR"},
+                        {Msg.get("abondance-R"),"R"},
+                        {Msg.get("abondance-AR"),"AR"},
+                        {Msg.get("abondance-PC"),"PC"},
+                        {Msg.get("abondance-AC"),"AC"},
+                        {Msg.get("abondance-C"),"C"},
+                        {Msg.get("abondance-CC"),"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", Msg.get("certain"));
+                        valeursCertitude.put("douteux", Msg.get("douteux"));
+                        valeursCertitude.put("aDeterminer", Msg.get("a-determiner"));
+                }
+                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 referentielNom = Msg.get("referentiel-"+infosReferentielNom.getCode());
+                        String[] valeur = {referentielNom, 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 = {
+                        {Msg.get("phenologie-00-09"), "00-09"},
+                        {Msg.get("phenologie-10-19"), "10-19"},
+                        {Msg.get("phenologie-11"), "11"},
+                        {Msg.get("phenologie-15"), "15"},
+                        {Msg.get("phenologie-20-29"), "20-29"},
+                        {Msg.get("phenologie-30-39"), "30-39"},
+                        {Msg.get("phenologie-40-49"), "40-49"},
+                        {Msg.get("phenologie-50-59"), "50-59"},
+                        {Msg.get("phenologie-60-69"), "60-69"},
+                        {Msg.get("phenologie-61"), "61"},
+                        {Msg.get("phenologie-65"), "65"},
+                        {Msg.get("phenologie-70-79"), "70-79"},
+                        {Msg.get("phenologie-80-89"), "80-89"},
+                        {Msg.get("phenologie-85"), "85"},
+                        {Msg.get("phenologie-90-99"), "90-99"},
+                        {Msg.get("phenologie-91"), "91"},
+                        {Msg.get("phenologie-95"), "95"}
+                };
+                SimpleStore storeAbondance = new SimpleStore(new String[] {"label","valeur"},valeurs);
+                storeAbondance.load();
+                return storeAbondance;
+        }
+        public static HashMap<String, String> getCorrespondanceGrilleObservationChampsTri() {
+                HashMap<String, String> correspondances = new HashMap<String, String>();
+                correspondances.put("etat_observation", "transmission");
+                correspondances.put("referentiel_taxo_observation", "nom_referentiel");
+                correspondances.put("nomSaisi_observation", "nom_sel");
+                correspondances.put("certitude", "certitude");
+                correspondances.put("nomRetenu_observation", "nom_ret");
+                correspondances.put("famille_observation", "famille");
+                correspondances.put("abondance", "abondance");
+                correspondances.put("phenologie", "phenologie");
+                correspondances.put("etat_observation", "transmission");
+                correspondances.put("lieu_observation", "ce_zone_geo");
+                correspondances.put("altitude_observation", "altitude");
+                correspondances.put("date_observation", "date_observation");
+                correspondances.put("ordre_observation", "ordre");
+                return correspondances;
+        }
+        public static HashMap<String, String> getCorrespondanceGrilleImageChampsTri() {
+                HashMap<String, String> correspondances = new HashMap<String, String>();
+                correspondances.put("num_image", "ordre");
+                correspondances.put("transmis", "transmission");
+                correspondances.put("obs_associees", "nom_sel");
+                correspondances.put("dat_image", "date_prise_de_vue");
+                correspondances.put("lie_image", "zone_geo");
+                correspondances.put("app_image", "appareil_fabriquant");
+                correspondances.put("note_image", "note_qualite");
+                correspondances.put("nom_original", "nom_original");
+                return correspondances;
+        }
+}

 /trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java
 New file
 ,0 → 1,1194
+package org.tela_botanica.client.observation;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.dao.InformationLocaliteDAO;
+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.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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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()) ;
+                        String[] infosRafraichissementLienExterne = {numeroNomenclaturalSaisiObservation, obs.getReferentielTaxo()};
+                        liExtVue.rafraichir(infosRafraichissementLienExterne, 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() ;
+                        }
+                        String[] infosRefNom = {numeroNomenclaturalSaisiObservation, referentielTaxo};
+                        liExtVue.rafraichir(infosRefNom, 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(Msg.get("question-supprimer-observation")+" ?")) {
+                        observationModele.supprimerObservation(r,numeroOrdre) ;
+                        }
+                }
+        }
+        public boolean listeAvoirObservations() {
+                return listeObservation.getStore().getCount() > 0;
+        }
+        // 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(Msg.get("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(Msg.get("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) {
+                        Window.alert(Msg.get("erreur-nb-obs-étiquettes")+".");
+                        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() ;
+                String[] stParams = {idImg, idObs};
+                if(Window.confirm(Msg.get("question-supprimer-lien-image-obs", stParams)+" ?"))
+                {
+                        mvz.supprimerLiaisonImage() ;
+                        observationModele.supprimerLiaisonImages(idImg,idObs) ;
+                }
+        }
+        public void supprimerObservations() {
+                if(listeObservation.getIdSelectionnees().length > 0) {
+                        if(Window.confirm(Msg.get("question-supprimer-observations-sel")+" ?")) {
+                                        String[] numObs = listeObservation.getIdSelectionnees();
+                                        String numObsapl = "" ;
+                                        for(int i = 0 ; i < numObs.length ; i++) {
+                                                numObsapl += numObs[i]+"," ;
+                                        }
+                                        observationModele.supprimerListeObservation(listeObservation,numObsapl) ;
+                        }
+                }
+                else
+                {
+                        Window.alert(Msg.get("aucune-observation-selectionnee"));
+                }
+        }
+        public void transmettreObservations(boolean publier) {
+                if(Utilisateur.getInstance().isIdentifie()) {
+                        if(listeObservation.getIdSelectionnees().length > 0) {
+                                String action = "" ;
+                                if(publier) {
+                                        action = Msg.get("rendre-publiques") ;
+                                }
+                                else {
+                                        action = Msg.get("rendre-privees") ;
+                                }
+                                String[] stParams = {action};
+                                if(Window.confirm(Msg.get("question-rendre-publique-privee-observations-sel", stParams)+" ?")) {
+                                        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(Msg.get("aucune-observation-selectionnee"));
+                        }
+                }
+                else
+                {
+                        if(publier) {
+                                if(Window.confirm(Msg.get("question-publication-observations-identifie"))) {
+                                        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(Msg.get("question-suppression-liaison-obs-mot-cle")+" ?")) {
+                                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, Rafraichissable r) {
+                observationModele.ajouterMotCleDansArbre(n, arbreMC, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                observationModele.supprimerMotCleDansArbre(n, arbreMC, r);
+        }
+        /**
+         * 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());
+        }
+        /**
+         * 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, getPanneauFiltres().getArbreMotsClesObservationVue());
+        }
+        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 obtenirInformationLocalite(Rafraichissable r, String nomLocalite, String codeLoc) {
+                observationModele.obtenirInformationLocalite(r, nomLocalite, codeLoc);
+        }
+        public void obtenirInformationCoord(double lat, double lng) {
+                this.obtenirInformationCoord(lat, lng, false);
+        }
+        public void obtenirInformationCoord(double lat, double lng, boolean zoomer) {
+                cartoObservationVue.setDoitZoomerSurRetour(true);
+                // Les requêtes hors France sont longues, on veille donc à ne pas les empiler
+                // inutilement pour ne pas les traiter au retour
+                InformationLocaliteDAO.annulerRequeteEnCours();
+                // Pour faire patienter l'utilisateur le temps de trouver la zone
+                //Util.curseurAttente();
+                afficherFenetreCarto();
+                cartoObservationVue.afficherCarteEnAttenteAvecMarker(lat, lng);
+                observationModele.obtenirInformationCoord(cartoObservationVue, lat, lng);
+        }
+        public void obtenirInformationLocalite(String nomLocalite, String codeLoc) {
+                observationModele.obtenirInformationLocalite(cartoObservationVue, nomLocalite, codeLoc);
+        }
+        /**
+         * Ouvre la fenêtre carto, place un marqueur sur le point demandé et centre l'affichage,
+         * mais ne recherche pas d'infos sur le point
+         * @param infos doit contenir des coordonnées (lon, lat)
+         */
+        public void rafraichirFenetreCartoSurPoint(EntiteGeographiqueObservation infos) {
+                cartoObservationVue.rafraichir(infos, false);
+        }
+        public void rafraichirSaisieLocaliteObservation(EntiteGeographiqueObservation infosLocalite) {
+                InformationLocaliteDAO.annulerRequeteEnCours();
+                formulaireSaisieObservationVue.rafraichir(infosLocalite, 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;
+        }
+        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;
+        }
+        public String renvoyerTri() {
+                return listeObservation.renvoyerTri();
+        }
+        public String renvoyerDirectionTri() {
+                return listeObservation.renvoyerDirectionTri();
+        }
+}

 /trunk/src/org/tela_botanica/client/observation/ObservationModele.java
 New file
 ,0 → 1,603
+package org.tela_botanica.client.observation;
+//TODO : normaliser les noms de methodes (obtenir, ajouter ...)
+import java.util.HashMap;
+import org.tela_botanica.client.i18n.Msg;
+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.InformationLocaliteDAO;
+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.ListeReferentielLocaliteAsynchroneDAO;
+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 org.tela_botanica.client.util.MotsClesUtilitaire;
+import com.google.gwt.json.client.JSONArray;
+import com.google.gwt.json.client.JSONObject;
+import com.google.gwt.user.client.Window;
+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) ;
+        /**
+         * 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+4][2] ;
+                        criteres2[0][0] = "limite" ;
+                        criteres2[0][1] = ""+taillePage ;
+                        criteres2[1][0] = "numero_page" ;
+                        criteres2[1][1] = ""+pageEncours ;
+                        criteres2[2][0] = "tri" ;
+                        criteres2[2][1] = ""+observationMediateur.renvoyerTri();
+                        criteres2[3][0] = "tri_dir";
+                        criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ;
+                        for(int i = 0 ; i < criteres.length ; i++)
+                        {
+                                criteres2[i+4][0] = criteres[i][0] ;
+                                criteres2[i+4][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);
+        }
+        /**
+         *
+         * 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) {
+                        JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
+                        Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre(Msg.get("projets"), "racine_obs", donneesArbre, false);
+                        arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
+                        motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
+                        // 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine_obs")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                motsCles.put(id, motCle);
+                String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="
+                                + motCle + "&id=" + id + "&parent=" + parentId;
+                MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
+                String[] usObj = (String[]) n.getUserObject();
+                String id = usObj[1];
+                rafraichirArbreMotsCles(arbreMC);
+                MCDao.supprimerBaseDeDonnees(id, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine_obs")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.modifierBaseDeDonnees(motCleModifie, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine_obs")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.deplacerBaseDeDonnees(motCleModifie, r);
+        }
+        /**
+         * 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 obtenirInformationLocalite(Rafraichissable r, String nomLocalite, String code) {
+                InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);
+                infoLocalite.obtenirInfosLocalite(r, nomLocalite, code);
+        }
+        public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
+                InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r);
+                infoLocalite.obtenirLocalitePlusProche(r, lng, lat);
+        }
+}

 /trunk/src/org/tela_botanica/client/util/FormulaireSaisieChampEtendu.java
 New file
 ,0 → 1,290
+package org.tela_botanica.client.util;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
+import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.event.dom.client.ChangeEvent;
+import com.google.gwt.event.dom.client.ChangeHandler;
+import com.google.gwt.http.client.Response;
+import com.google.gwt.http.client.URL;
+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.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.ListBox;
+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.Panel;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.form.FormPanel;
+import com.gwtext.client.widgets.layout.FormLayout;
+@SuppressWarnings("unchecked")
+public abstract class FormulaireSaisieChampEtendu extends FormPanel implements Rafraichissable {
+        final AutoCompletionComboBox nChamp;
+        Button ajouterChampsEtenduEtFermer;
+        Button ajouterChampsEtendu;
+        Button annulerAjouterChampEtendu;
+        String idChamp = null;
+        Panel conteneurGroupesChampsEtendus;
+        Panel conteneurlabelGroupe;
+        ListBox listeGroupeChampsEtendus;
+        HTML indicationSaisieGroupe;
+        private static ListeGroupesChampsEtendus cacheGroupes;
+        private static Map<String, String> cacheLabelsCle;
+        private HTML descriptionChamp = null;
+    private String groupeSelectionne = null;
+        public FormulaireSaisieChampEtendu() {
+                super();
+                setPaddings(3);
+                setBodyBorder(false);
+                indicationSaisieGroupe = new HTML(Msg.get("indication-saisie-groupe-champ-etendus"));
+                indicationSaisieGroupe.addStyleName("aideCreerChampEtendu");
+                conteneurlabelGroupe = new Panel();
+                conteneurlabelGroupe.setStyleName("panneauEnLigne");
+                conteneurlabelGroupe.addStyleName("selecteurGroupeEtendus");
+                conteneurlabelGroupe.setBorder(false);
+                Label labelGroupeChampsEtendus = new Label(Msg.get("ajouter-groupe-champ-etendus")+" :");
+                listeGroupeChampsEtendus = new ListBox();
+                listeGroupeChampsEtendus.setWidth("315px");
+                conteneurlabelGroupe.add(labelGroupeChampsEtendus);
+                conteneurlabelGroupe.add(listeGroupeChampsEtendus);
+                conteneurGroupesChampsEtendus = new Panel();
+                conteneurGroupesChampsEtendus.setBorder(false);
+                conteneurGroupesChampsEtendus.setPaddings(0);
+                conteneurGroupesChampsEtendus.setMargins(0);
+                conteneurGroupesChampsEtendus.setLayout(new FormLayout());
+                conteneurGroupesChampsEtendus.setWidth("100%");
+                add(conteneurGroupesChampsEtendus);
+                if(cacheGroupes == null) {
+                        ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
+                        lrceDao.obtenirGroupesChampsEtendus(this);
+                } else {
+                        this.rafraichir(cacheGroupes, false);
+                }
+                HTML indicationSaisie = new HTML(Msg.get("indication-saisie-nom-champ-etendu"));
+                indicationSaisie.addStyleName("aideCreerChampEtendu");
+                add(indicationSaisie);
+                HorizontalPanel hp = new HorizontalPanel();
+                hp.setBorderWidth(0);
+                nChamp = new AutoCompletionComboBox(Msg.get("nom-champ-etendu"), ListeReferentielChampsEtendusDAO.getUrlRequeteNomsChampsEtendus()) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(
+                                        Response response) {
+                                Map<String, String> clesLabels = ListeReferentielChampsEtendusDAO.parserRetourListeNomsChampsEtendus(response);
+                                cacheLabelsCle = new HashMap<String, String>();
+                                for(Map.Entry<String, String> entry : clesLabels.entrySet()){
+                                        cacheLabelsCle.put(entry.getValue(), entry.getKey());
+                                }
+                                return clesLabels;
+                        }
+                        @Override
+                        protected void onSelectionValeur() {
+                                telechargerEtAfficherDescriptionChamps(cacheLabelsCle.get(nChamp.getRawValue()));
+                        }
+                        @Override
+                        protected void onValidationSaisie() {
+                                // rien à faire ici
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                // rien à faire ici non plus
+                        }
+                        @Override
+                        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                                return urlRequete.replace("{utilisateur}", Utilisateur.getInstance().getIdentifiantUtilisateurConsulte())+URL.encodeQueryString(valeur);
+                        }
+                };
+                nChamp.addStyleName("panneauEnLigne");
+                add(nChamp);
+                descriptionChamp = new HTML();
+                descriptionChamp.addStyleName("aideWikiChampEtendu");
+                add(descriptionChamp);
+                ajouterChampsEtenduEtFermer = new Button(Msg.get("ajouter-fermer"));
+                ajouterChampsEtenduEtFermer.setTooltip(Msg.get("indication-ajouter-fermer"));
+                ajouterChampsEtendu = new Button(Msg.get("ajouter"));
+                ajouterChampsEtendu.setTooltip(Msg.get("indication-ajouter-champ-etendu"));
+                annulerAjouterChampEtendu = new Button(Msg.get("fermer"));
+                annulerAjouterChampEtendu.setTooltip(Msg.get("indication-fermer-champ-etendu"));
+                hp.add(ajouterChampsEtenduEtFermer);
+                hp.add(ajouterChampsEtendu);
+                hp.add(annulerAjouterChampEtendu);
+                add(hp);
+                ajouterListeners();
+        }
+        private void ajouterListeners() {
+            listeGroupeChampsEtendus.addChangeHandler(new ChangeHandler() {
+                        @Override
+                        public void onChange(ChangeEvent event) {
+                                groupeSelectionne = listeGroupeChampsEtendus.getValue(listeGroupeChampsEtendus.getSelectedIndex());
+                        }
+                });
+            ajouterChampsEtenduEtFermer.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                if(doitAjouterGroupe()) {
+                                        surValidationMultiple(renvoyerListeChampsEtendus(groupeSelectionne));
+                                } else {
+                                        if(champEtenduEstValide()) {
+                                                surValidation(validerEtRenvoyerChampEtendu());
+                                        } else {
+                                                Window.alert(Msg.get("erreur-nom-vide-champ-etendu"));
+                                        }
+                                }
+                        }
+                });
+            ajouterChampsEtendu.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                if(champEtenduEstValide()) {
+                                        surAjout(validerEtRenvoyerChampEtendu());
+                                        raz();
+                                } else {
+                                        Window.alert(Msg.get("erreur-nom-vide-champ-etendu"));
+                                }
+                        }
+                });
+            annulerAjouterChampEtendu.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                surAnnulation();
+                        }
+                });
+        }
+        public void redimensionner(int largeur) {
+                nChamp.redimensionner(largeur);
+        }
+        private void raz() {
+                idChamp = null;
+                nChamp.reset();
+                nChamp.focus();
+        }
+        private ChampSaisieEtendu validerEtRenvoyerChampEtendu() {
+                String labelChamp = nChamp.getRawValue();
+                String cleChamp = cacheLabelsCle.containsKey(labelChamp) ? cacheLabelsCle.get(labelChamp) : labelChamp;
+                ChampSaisieEtendu retour = new ChampSaisieEtendu(labelChamp, cleChamp, ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(cleChamp));
+                retour.setId(cleChamp);
+                return retour;
+        }
+        private List<ChampSaisieEtendu> renvoyerListeChampsEtendus(String groupe) {
+                List<ChampSaisieEtendu> champsDuGroupe = new ArrayList<ChampSaisieEtendu>();
+                HashMap<String, String> listeChampsEtendus = cacheGroupes.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,  ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(cle));
+                        champsDuGroupe.add(champ);
+                }
+                return champsDuGroupe;
+        }
+        private boolean doitAjouterGroupe() {
+                return groupeSelectionne != null && !groupeSelectionne.equals("");
+        }
+        private boolean champEtenduEstValide() {
+                String valeurChamp = nChamp.getRawValue();
+                return (valeurChamp != null && !valeurChamp.isEmpty());
+        }
+        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) {
+                if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) {
+                        cacheGroupes  = (ListeGroupesChampsEtendus)nouvelleDonnees;
+                        listeGroupeChampsEtendus.addItem("...");
+                        for (Iterator<String> iterator = cacheGroupes.keySet().iterator(); iterator.hasNext();) {
+                                listeGroupeChampsEtendus.addItem(iterator.next());
+                        }
+                        if(cacheGroupes.size() > 0) {
+                                conteneurGroupesChampsEtendus.add(indicationSaisieGroupe);
+                                conteneurGroupesChampsEtendus.add(conteneurlabelGroupe);
+                                doLayout();
+                        }
+                }
+        }
+    private void telechargerEtAfficherDescriptionChamps(final String cle) {
+                ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() {
+                        @Override
+                        public void onSuccess(String description) {
+                                afficherDescriptionEtLienWikiChampEtendu(cle, description);
+                        }
+                        @Override
+                        public void onFailure(String reason) {
+                                // rien
+                        }
+                });
+        }
+    private void afficherDescriptionEtLienWikiChampEtendu(final String cle, String description) {
+        if(description.trim().isEmpty()) {
+                        String urlDesc = ListeReferentielChampsEtendusDAO.obtenirUrlEditionDescriptionWiki(cle);
+                        descriptionChamp.setHTML("<span> "+Msg.get("indication-aucune-description-champ-etendu")+".<br />" +
+                                        Msg.get("indication-aucune-description-champ-etendu-remplir")+" :" +
+                                        "<a id=\"lien_description_wiki_ce_"+cle+"\" href="+urlDesc+" target=\"_blank\">"+cle+"</span></span>");
+                        Ext.get("lien_description_wiki_ce_"+cle).addListener("click", new EventCallback() {
+                                @Override
+                                public void execute(EventObject e) {
+                                        ListeReferentielChampsEtendusDAO.creerPageWikini(cle);
+                                }
+                        });
+                } else {
+                        descriptionChamp.setHTML("<span class=\"descriptionChampEtenduTitre\">"+Msg.get("description")+" :</span> "+description);
+                }
+    }
+}

 /trunk/src/org/tela_botanica/client/util/autocompletion/AutoCompletionComboBox.java
 New file
 ,0 → 1,334
+package org.tela_botanica.client.util.autocompletion;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.tela_botanica.client.cel2;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+import com.google.gwt.event.dom.client.KeyDownHandler;
+import com.google.gwt.event.dom.client.KeyPressEvent;
+import com.google.gwt.event.dom.client.KeyPressHandler;
+import com.google.gwt.event.logical.shared.SelectionEvent;
+import com.google.gwt.event.logical.shared.SelectionHandler;
+import com.google.gwt.event.logical.shared.ValueChangeEvent;
+import com.google.gwt.event.logical.shared.ValueChangeHandler;
+import com.google.gwt.http.client.Request;
+import com.google.gwt.http.client.RequestBuilder;
+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.Event;
+import com.google.gwt.user.client.Timer;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.ui.ChangeListener;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.MultiWordSuggestOracle;
+import com.google.gwt.user.client.ui.SuggestBox;
+import com.google.gwt.user.client.ui.SuggestBox.DefaultSuggestionDisplay;
+import com.google.gwt.user.client.ui.TextBox;
+import com.google.gwt.user.client.ui.SuggestBox.SuggestionDisplay;
+import com.google.gwt.user.client.ui.SuggestOracle;
+import com.google.gwt.user.client.ui.Widget;
+import com.google.gwt.user.client.ui.SuggestOracle.Suggestion;
+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.PanelListener;
+import com.gwtext.client.widgets.event.PanelListenerAdapter;
+import com.gwtext.client.widgets.layout.FitLayout;
+@SuppressWarnings("unchecked")
+public abstract class AutoCompletionComboBox extends Panel {
+        Label label = null;
+        MultiWordSuggestOracle msu = null;
+        SuggestBox suggestions = null;
+        DefaultSuggestionDisplay sgd = null;
+        Callback<String, String> surCopierColler = null;
+        SuggestOracle.Request requeteOracle;
+    SuggestOracle.Callback callBackOracle;
+        Timer suggestionTimer = null;
+    int tempsAvantRequete = 500;
+    Map<String, String> possibilites = null;
+    String urlRequete = "";
+        public AutoCompletionComboBox(String nomLabel, String urlRequete) {
+                this.setStyleName("champAutoComplete");
+                this.label = new Label(nomLabel+":");
+                this.urlRequete = urlRequete;
+                sgd = new SuggestBox.DefaultSuggestionDisplay();
+                msu = new MultiWordSuggestOracle() {
+                        @Override
+                        public void requestSuggestions(Request request, Callback callback) {
+                                List<MultiWordSuggestion> retenus = new ArrayList<MultiWordSuggestion>();
+                                Iterator<String> it = possibilites.keySet().iterator();
+                            while (it.hasNext()) {
+                                String cle = it.next();
+                                String cleAffichee = preTraiterValeurAvantAffichage(possibilites.get(cle));
+                                        MultiWordSuggestion muWoSug = new MultiWordSuggestion(possibilites.get(cle), cleAffichee);
+                                        retenus.add(muWoSug);
+                            }
+                                Response reponse = new Response(retenus);
+                                callback.onSuggestionsReady(request, reponse);
+                        }
+                };
+                suggestions = new SuggestBox(msu, new TextBox(), sgd) {
+                        public void onBrowserEvent(Event event) {
+                            switch (event.getTypeInt()) {
+                                case Event.ONPASTE: {
+                                        if(surCopierColler != null) {
+                                                surCopierColler.onSuccess(suggestions.getValueBox().getValue());
+                                        }
+                                }
+                                break;
+                                default:
+                                        // WTF: Curieux bloc qui est nécessaire car si on appelle pas super.onBrowserEvent
+                                        // aucun évènement ne fonctionne et si on le fait, cela génère des nullPointerException
+                                        // donc on transige en l'appelant dans un try catch
+                                        try {
+                                                super.onBrowserEvent(event);
+                                        } catch (Exception e) {
+                                                // à priori rien à faire
+                                        }
+                            }
+                        }
+                };
+                suggestions.setAutoSelectEnabled(false);
+                setLayout(new FitLayout());
+                add(label);
+                add(suggestions);
+                gererEvenements();
+        }
+        public void gererEvenements() {
+                suggestions.addKeyDownHandler(new KeyDownHandler() {
+                    @Override
+                    public void onKeyDown(KeyDownEvent event) {
+                        // Lorsque la liste de suggestions est ouverte, une frappe sur entrée selectionne la valeur
+                        // Si elle est fermée, elle déclenche la fonction abstraite de validation (utile pour les champs
+                        // du genre station, milieu etc... et la saisie d'obs rapide
+                                if(event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+                                        if((sgd == null || !sgd.isSuggestionListShowing())) {
+                                                onValidationSaisie();
+                                                event.stopPropagation();
+                                                return;
+                                        } else {
+                                                // Dans les autres cas, un appui sur entrée ne doit pas redéclencher l'autcomplétion
+                                                return;
+                                        }
+                                }
+                                if(event.getNativeKeyCode() == KeyCodes.KEY_DOWN) {
+                                        // Un appui sur flèche bas permet de demander toute la liste
+                                        if(!sgd.isSuggestionListShowing()) {
+                                                requeteToutesSuggestions();
+                                        }
+                                }
+                                // Tout autre frappe d'un caractère "normal" déclenche le timer d'autocomplétion
+                                if(!KeyDownEvent.isArrow(event.getNativeKeyCode())) {
+                                        gererTimer();
+                                }
+                    }
+                });
+                requeteOracle = new SuggestOracle.Request();
+                callBackOracle = new SuggestOracle.Callback() {
+                        public void onSuggestionsReady(SuggestOracle.Request request, SuggestOracle.Response response) {
+                                suggestions.showSuggestionList();
+                        }
+            };
+            suggestions.addSelectionHandler(new SelectionHandler<SuggestOracle.Suggestion>(){
+                        @Override
+                        public void onSelection(SelectionEvent<Suggestion> event) {
+                                onSelectionValeur();
+                        }
+                });
+            suggestions.addValueChangeHandler(new ValueChangeHandler<String>() {
+                        @Override
+                        public void onValueChange(ValueChangeEvent<String> event) {
+                                onModificationValeur();
+                        }
+                });
+            surCopierColler = new Callback<String, String>() {
+                        @Override
+                        public void onSuccess(String result) {
+                                gererTimer();
+                        }
+                        @Override
+                        public void onFailure(String reason) {
+                                // rien à faire ça n'échoue jamais
+                        }
+                };
+                addListener(new PanelListenerAdapter() {
+                        @Override
+                        public void onResize(BoxComponent component, int adjWidth, int adjHeight,
+                                        int rawWidth, int rawHeight) {
+                                redimensionner(rawWidth);
+                        }
+                });
+        }
+        public void redimensionner(final int largeur) {
+                suggestions.setWidth((largeur - label.getOffsetWidth() - 13)+"px");
+        }
+        public void gererTimer() {
+                if(suggestionTimer == null) {
+                        suggestionTimer = new Timer() {
+                                public void run() {
+                                        requeteSuggestions();
+                                }
+                        };
+                        suggestionTimer.schedule(tempsAvantRequete);
+                } else {
+                        suggestionTimer.schedule(tempsAvantRequete);
+                }
+        }
+        public void setTempsAvantRequete(int temps) {
+                tempsAvantRequete = temps;
+        }
+        public int getTempsAvantRequete(int temps) {
+                return tempsAvantRequete;
+        }
+        public void requeteToutesSuggestions() {
+                // Cette méthode permet de demander l'autocomplétion même si
+                // la valeur saisie est vide (cas de l'appui sur flèche bas)
+                envoyerRequeteSuggestions("*");
+        }
+        public void requeteSuggestions() {
+                // Suppression des espaces et caractères inutiles
+                String valeur = suggestions.getValue().trim().isEmpty() ? null : suggestions.getValue().trim();
+                // ceci permet au composant qui utilise l'autocomplétion
+                // d'annuler une requete et également d'éviter de faire une requête lors du vidage du champ
+                if(valeur == null) {
+                        return;
+                }
+                envoyerRequeteSuggestions(valeur);
+        }
+        private void envoyerRequeteSuggestions(final String valeur) {
+                final String urlRequeteFmt = preTraiterUrlRequete(urlRequete, valeur);
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, urlRequeteFmt) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(final Request request, final Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(final Request request,
+                                                final Response response) {
+                                        surReponseRequete(valeur, response);
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        public void surReponseRequete(String requete, Response response) {
+                possibilites = parserResultatRequete(response);
+                msu.clear();
+                Iterator<String> it = possibilites.keySet().iterator();
+            while (it.hasNext()) {
+                msu.add(possibilites.get(it.next()));
+            }
+                requeteOracle.setQuery(requete);
+                if(requete.equals("*")) {
+                        // TODO : il y a peut être une méthode plus simple
+                        // mais ceci permet d'afficher les suggestions en cas d'appui
+                        // sur bas lorsque la liste est vide
+                        msu.setDefaultSuggestionsFromText(possibilites.values());
+                        SuggestOracle.Request rq = new SuggestOracle.Request();
+                        rq.setQuery(null);
+                        msu.requestDefaultSuggestions(rq, callBackOracle);
+                } else {
+                        msu.requestSuggestions(requeteOracle, callBackOracle);
+                }
+        }
+        public String getText() {
+                return suggestions.getText();
+        }
+        public String getRawValue() {
+                return suggestions.getText();
+        }
+        public void setValue(String texte) {
+                suggestions.setText(texte);
+        }
+        public void reset() {
+                suggestions.setValue("");
+        }
+        public void setTabIndex(int index) {
+                suggestions.setTabIndex(index);
+        }
+        public String getLabelText() {
+                return label.getText();
+        }
+        public int getFieldWidth() {
+                return suggestions.getOffsetWidth();
+        }
+        public int getLabelWidth() {
+                return label.getOffsetWidth();
+        }
+        public void agrandirChamp(int largeur) {
+                suggestions.setWidth(largeur+"px");
+        }
+        protected String preTraiterValeurAvantAffichage(String valeur) {
+                return valeur;
+        }
+        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                return urlRequete+URL.encodeQueryString(valeur);
+        }
+        protected abstract Map<String, String> parserResultatRequete(Response response);
+        protected abstract void onModificationValeur();
+        protected abstract void onSelectionValeur();
+        protected abstract void onValidationSaisie();
+}

 /trunk/src/org/tela_botanica/client/util/MotsClesUtilitaire.java
 New file
 ,0 → 1,207
+package org.tela_botanica.client.util;
+import java.util.HashMap;
+import org.tela_botanica.client.cel2;
+import com.google.gwt.json.client.JSONArray;
+import com.google.gwt.json.client.JSONObject;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.widgets.tree.TreeNode;
+public class MotsClesUtilitaire {
+        //TODO rassembler tout ce qui construit les arbres de mots clés ici
+        private static String[] caracteresInterdits = {"\\", "/", ","};
+        public static String obtenirCheminParent(String cheminMotCle) {
+                String[] tabChemin = cheminMotCle.split("/");
+                String cheminParent = "/";
+                if(tabChemin.length >= 1) {
+                        for(int i = 1; i < tabChemin.length - 1; i++) {
+                                cheminParent += tabChemin[i]+"/";
+                        }
+                }
+                return cheminParent;
+        }
+        public static Object[] construireArbre(String NomRacine, String idRacine,
+                        JSONArray arbreJson, boolean afficherCheckbox) {
+                Tree arbreMotsCles = new Tree() ;
+                HashMap<String, String> motsCles = new HashMap<String, String>(0);
+                HashMap<String, String> parentes = new HashMap<String, String>();
+                final int taillemax = arbreJson.size();
+                // on crée un arbre vide
+                TreeNode root = new TreeNode();
+                root.setId(idRacine);
+                root.setText(NomRacine);
+                String[] usObjRacine = {NomRacine, idRacine};
+                root.setUserObject(usObjRacine);
+                arbreMotsCles.setRootNode(root);
+                // le mot clé racine possède le chemin racine ("/")
+                parentes.put("/", idRacine);
+                // pour chacun des élements du tableau
+                for (int j = 0; j < taillemax; j++) {
+                        // on extrait les élements du tableau
+                        if (arbreJson.get(j).isObject() != null) {
+                                JSONObject noeud = (JSONObject) arbreJson.get(j);
+                                String idMotCle = noeud.get("id_mot_cle")
+                                                .isString().stringValue();
+                                String motCle = noeud.get("mot_cle").isString()
+                                                .stringValue();
+                                // le chemin est mis en minuscule afin de fusionner toutes
+                                // la variantes minuscules majuscule d'un mot clé
+                                // qui peuvent poser problème
+                                String chemin = noeud.get("chemin").isString()
+                                                .stringValue().toLowerCase();
+                                String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin);
+                                String parent = parentes.get(cheminParent);
+                                String[] usObj = {motCle, idMotCle};
+                                // et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés
+                                // dans l'ordre hierarchique de leur niveau
+                                // ce qui permet de les traiter séquentiellement)
+                                TreeNode node = new TreeNode();
+                                node.setId(idMotCle);
+                                node.setText(motCle);
+                                if(afficherCheckbox) {
+                                        node.setChecked(false);
+                                }
+                                Node parentNode = arbreMotsCles.getNodeById(parent);
+                                node.setUserObject(usObj);
+                                parentNode.appendChild(node);
+                                parentes.put(chemin, idMotCle);
+                                motsCles.put(idMotCle, motCle);
+                        }
+                }
+                Object[] retour = {arbreMotsCles, motsCles};
+                return retour;
+        }
+        /**
+         * 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
+         */
+        public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie, boolean afficherCheckbox) {
+                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]);
+                                if(afficherCheckbox) {
+                                        child.setChecked(false);
+                                }
+                                child.setUserObject(usObj);
+                                ndPereCopie.appendChild(child);
+                                if (!ndNodeFils[i].isLeaf()) {
+                                        copierFilsNoeud(ndNodeFils[i], child, afficherCheckbox);
+                                }
+                        }
+                }
+        }
+        public static TreeNode ajouterNoeud(TreeNode parent, boolean afficherCheckbox) {
+                // on crée un nouveau noeud vide
+                TreeNode nd = new TreeNode("");
+                nd.setCls("x-view-treenode-keyword");
+                if(afficherCheckbox) {
+                        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] = "";
+                nd.setUserObject(usObject);
+                String cheminTemporaireAjout = parent.getPath()+"/"+nd.getId();
+                nd.setId(cheminTemporaireAjout);
+                return nd;
+        }
+        public static String getChaineCaracteresInterdits() {
+                String interdits = "";
+                for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
+                        interdits += MotsClesUtilitaire.caracteresInterdits[i]+" ";
+                }
+                return interdits;
+        }
+        public static boolean estUnMotCleAutorise(String motCle) {
+                boolean valide = !motCle.trim().isEmpty();
+                for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
+                        if(motCle.indexOf(MotsClesUtilitaire.caracteresInterdits[i]) != -1) {
+                                valide = false;
+                                break;
+                        }
+                }
+                return valide;
+        }
+        public static boolean estUnePositionAutorisee(TreeNode node, Node parent, String text) {
+                if(parent == null) {
+                        parent = node.getParentNode();
+                }
+                text = normaliserChaine(text);
+                Node[] noeudsFreres = parent.getChildNodes();
+                boolean ok = true;
+                for(int i = 0; i <= noeudsFreres.length; i++) {
+                        if(noeudsFreres[i] != null) {
+                                String cheminFrere = normaliserChaine(noeudsFreres[i].getPath());
+                                String cheminNoeud = normaliserChaine(node.getPath());
+                                String texteNoeudfrere = normaliserChaine(((String[])noeudsFreres[i].getUserObject())[0]);
+                                if(!cheminFrere.equals(cheminNoeud) && text.equals(texteNoeudfrere)) {
+                                        ok = false;
+                                }
+                        }
+                }
+                return ok;
+        }
+        public static String normaliserChaine(String chaine) {
+                return supprimerAccents(chaine).toLowerCase().trim();
+        }
+        public static String supprimerAccents(String chaine) {
+            String s = chaine;
+            s = s.replaceAll("[èéêë]","e");
+            s = s.replaceAll("[ûùü]","u");
+            s = s.replaceAll("[ïî]","i");
+            s = s.replaceAll("[àâ]","a");
+            s = s.replaceAll("ô","o");
+            s = s.replaceAll("[ÈÉÊË]","E");
+            s = s.replaceAll("[ÛÙÜ]","U");
+            s = s.replaceAll("[ÏÎ]","I");
+            s = s.replaceAll("[ÀÂ]","A");
+            s = s.replaceAll("Ô","O");
+            return s;
+        }
+}

 /trunk/src/org/tela_botanica/client/util/Analytics.java
 New file
 ,0 → 1,68
+package org.tela_botanica.client.util;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.util.Util;
+public class Analytics {
+        /**
+         * Envoie une notification à Google Analytics, comme quoi la page "url" a été visitée;
+         * passer par pageVisitee() pour s'assurer qu'on est bien en prod
+         *
+         * @param url adresse ou surnom de la page visitée
+         */
+        public static native void pageVisiteeNatif(String url) /*-{
+                if (url == "") {
+                        url = $wnd.location.href;
+                }
+                $wnd.ga('send', 'pageview', url);
+        }-*/;
+        /**
+         * Proxy pour evenementNatif() qui n'envoie l'événement que si on est en prod
+         */
+        public static void pageVisitee(String url) {
+                if (Configuration.isProd()) {
+                        //Util.LogVersFirebug("Page vue: " + url);
+                        Analytics.pageVisiteeNatif(url);
+                } else {
+                }
+        }
+        public static void pageVisitee() {
+                pageVisitee("");
+        }
+        /**
+         * Envoie une notification à Google Analytics, comme quoi l'événement "action" a été déclenché
+         * sur la ressource "categorie" - passer par evenement() pour s'assurer qu'on
+         * est bien en prod
+         *
+         * @param categorie - la ressource sur laquelle l'utilisateur a agi
+         * @param action - ce que l'utilisateur a fait avec cette ressource
+         * @param label - un bout de JSON avec des détails
+         * @param nombre - nombre d'actions à enregistrer
+         */
+        public static native void evenementNatif(String categorie, String action, String label, int nombre) /*-{
+                $wnd.ga('send', 'event', categorie, action, label, nombre);
+        }-*/;
+        /**
+         * Proxy pour evenementNatif() qui n'envoie l'événement que si on est en prod
+         */
+        public static void evenement(String categorie, String action, String label, int nombre) {
+                if (Configuration.isProd()) {
+                        //Util.LogVersFirebug("Evenement: " + categorie + ", " + action + ", " + label + ", " + nombre);
+                        Analytics.evenementNatif(categorie, action, label, nombre);
+                }
+        }
+        public static void evenement(String categorie, String action, String label) {
+                Analytics.evenement(categorie, action, label, 1);
+        }
+        public static void evenement(String categorie, String action) {
+                Analytics.evenement(categorie, action, "", 1);
+        }
+}

 /trunk/src/org/tela_botanica/client/util/RequestBuilderWithCredentials.java
 New file
 ,0 → 1,28
+package org.tela_botanica.client.util;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import com.google.gwt.http.client.RequestBuilder;
+public class RequestBuilderWithCredentials extends RequestBuilder {
+        /**
+         * Crée une requête avec des headers "Credentials" pour CORS et "Authorization" contenant
+         * le jeton (s'il existe)
+         */
+        public RequestBuilderWithCredentials(Method httpMethod, String url) {
+                this(httpMethod, url, true);
+        }
+        /**
+         * Crée une requête avec des headers "Credentials" pour CORS, et si authorizationHeader vaut true,
+         * un header "Authorization" contenant le jeton (s'il existe)
+         */
+        public RequestBuilderWithCredentials(Method httpMethod, String url, boolean authorizationHeader) {
+                super(httpMethod, url);
+                if(authorizationHeader && (Utilisateur.getJeton() != null && !Utilisateur.getJeton().isEmpty())) {
+                        this.setHeader("Authorization", Utilisateur.getJeton());
+                }
+                this.setIncludeCredentials(true);
+        }
+}

 /trunk/src/org/tela_botanica/client/util/ChampSaisieEtendu.java
 New file
 ,0 → 1,122
+package org.tela_botanica.client.util;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.tela_botanica.client.cel2;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.http.client.Response;
+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.ToolTip;
+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 AutoCompletionComboBox {
+                private String cle = null;
+                private String label = null;
+                private String description = null;
+                private ToolTip tpDesc = null;
+                public ChampSaisieEtendu(String label, String cle, String urlRequete) {
+                        super(label, urlRequete);
+                        this.cle =cle;
+                        this.label = label;
+                        // A activer pour télécharger la description
+                        // si jamais on le décide
+                        addListener(new ComboBoxListenerAdapter() {
+                                @Override
+                                public void onRender(Component component) {
+                                        ChampSaisieEtendu.this.getEl().addListener("mouseover", new EventCallback() {
+                                                @Override
+                                                public void execute(EventObject e) {
+                                                        if(description == null) {
+                                                                telechargerEtAfficherDescriptionDistante();
+                                                        } else {
+                                                                afficherDescription(description);
+                                                        }
+                                                }
+                                        });
+                                }
+                        });
+                }
+                private void telechargerEtAfficherDescriptionDistante() {
+                        ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() {
+                                @Override
+                                public void onSuccess(String description) {
+                                        ChampSaisieEtendu.this.description = description;
+                                        afficherDescription(description);
+                                }
+                                @Override
+                                public void onFailure(String description) {
+                                        afficherDescription(description);
+                                }
+                        });
+                }
+                private void afficherDescription(String description) {
+                        if(!description.trim().isEmpty()) {
+                                if(tpDesc == null) {
+                                        tpDesc = new ToolTip(description);
+                                        tpDesc.applyTo(this.getElement());
+                                        tpDesc.showAt(ChampSaisieEtendu.this.getEl().getX(), ChampSaisieEtendu.this.getEl().getY());
+                                } else {
+                                        tpDesc.show();
+                                }
+                        }
+                }
+                public String getCle() {
+                        return cle;
+                }
+                public String getLabel() {
+                        return label;
+                }
+                @Override
+                protected Map<String, String> parserResultatRequete(Response response) {
+                        return ListeReferentielChampsEtendusDAO.parserRetourListeValeursChampsEtendus(response);
+                }
+                @Override
+                protected void onModificationValeur() {
+                        // TODO Auto-generated method stub
+                }
+                @Override
+                protected void onSelectionValeur() {
+                        // TODO Auto-generated method stub
+                }
+                @Override
+                protected void onValidationSaisie() {
+                        // TODO Auto-generated method stub
+                }
+}

 /trunk/src/org/tela_botanica/client/util/Util.java
 New file
 ,0 → 1,636
+package org.tela_botanica.client.util;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Vector;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.modeles.objets.ChampEtendu;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.modeles.objets.Observation;
+import org.tela_botanica.client.modeles.objets.ReferentielLocalite;
+import org.tela_botanica.client.modeles.objets.ReferentielNom;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.http.client.Request;
+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.JSONString;
+import com.google.gwt.json.client.JSONValue;
+import com.google.gwt.user.client.ui.RootPanel;
+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 = cle;
+                                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 localite = obs.getLocalite();
+                String lieuDit = obs.getLieudit();
+                String station = obs.getStation();
+                String lieulocaliteFormate = "";
+                String lieuDitFormate = "";
+                String stationFormatee = "";
+                if(localite != null && !localite.contains("000null") && !localite.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);
+                                }
+                                lieulocaliteFormate += idLoc+" - ";
+                        }
+                        lieulocaliteFormate += localite;
+                        lieuModele = lieuModele.replaceAll("IDLOCLOCALITE", lieulocaliteFormate);
+                } else {
+                        lieuModele = lieuModele.replaceAll("IDLOCLOCALITE,", lieulocaliteFormate);
+                }
+                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 obtenirIdLocAPartirChaineLocalite(String localite) {
+                String idLoc = "";
+                String[] depCom = localite.split(" ");
+                if(depCom.length > 1) {
+                        idLoc = depCom[1].replace('(', ' ');
+                } else {
+                        idLoc = "";
+                }
+                idLoc = idLoc.replace(')', ' ');
+                idLoc = idLoc.trim();
+                idLoc = idLoc.replace('\\',' ');
+                idLoc = idLoc.trim();
+                return idLoc;
+        }
+        public static String formaterDepartement(String depAFormater) {
+                String dep = "";
+                try
+                {
+                        int nDep = Integer.parseInt(depAFormater);
+                        if(nDep > 0 && nDep < 110) {
+                                dep = depAFormater ;
+                        }
+                        if(depAFormater.length() == 4) {
+                                dep = "0"+depAFormater;
+                        }
+                        dep = depAFormater.substring(0,2);
+                }
+                catch(NumberFormatException e)
+                {
+                        // rien à faire
+                }
+                return dep;
+        }
+        public static String supprimerChaineIdLocalite(String chaineLocaliteComplete) {
+                return chaineLocaliteComplete.replaceAll(" \\([a-zA-Z0-9]*\\)", "").trim();
+        }
+        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) {
+                if(numMois >= 1 && numMois <= 12) {
+                        return Msg.get("mois-"+numMois);
+                } else {
+                        return Msg.get("mois-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 boolean estUnNombre(String s) {
+                //http://stackoverflow.com/questions/1102891/how-to-check-if-a-string-is-a-numeric-type-in-java
+                try {
+                        double d = Double.parseDouble(s);
+                } catch(NumberFormatException nfe) {
+                        return false;
+                }
+                return true;
+        }
+        public static boolean estLaCorse(String s) {
+                // Les générations futures d'informaticiens me jugeront
+                // (et éventuellement géreront mieux le cas de la Corse que je ne l'ai fait)
+                return s.toUpperCase().equals("2A") || s.toUpperCase().equals("2B");
+        }
+        public static boolean estUnDepartement(String s) {
+                return estUnNombre(s) || estLaCorse(s);
+        }
+        public static String formaterNombre(String s) {
+                s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");
+                return s;
+        }
+        // Prend un nombre décimal avec le spéparateur spécifié et le tronque à n décimales
+        public static String tronquerNombrePourAffichage(String nombre, int decimales, char separateur) {
+                String retour = nombre;
+                int posSep = nombre.indexOf(separateur);
+                if (posSep >= 0) {
+                        int taille = posSep + decimales + 1;
+                        if (nombre.length() < taille) {
+                                taille = nombre.length();
+                        }
+                        retour = nombre.substring(0, taille);
+                }
+                return retour;
+        }
+        public static String tronquerNombrePourAffichage(String nombre, int decimales) {
+                return tronquerNombrePourAffichage(nombre, decimales, '.');
+        }
+        // Adapté de http://www.programcreek.com/2011/03/java-method-for-spliting-a-camelcase-string/
+        public static String formaterCleChampsEtenduPourAffichage(String s) {
+                char[] cArray = s.toCharArray();
+                Vector<Integer> al = new Vector<Integer>();
+                al.add(0);
+                // get all upper case letter index positions
+                for (int i = 1; i < cArray.length; i++) {
+                        char c = cArray[i];
+                        //add more interested index beyond upper case letter
+                        if (c >= 65 && c <= 90) {
+                                al.add(i);
+                        }
+                }
+                Vector<String> strl = new Vector<String>();
+                // this handles the all lower letter case
+                if (al.size() == 1) {
+                        strl.add(s);
+                        return depilerChaineListee(strl, " ");
+                }
+                int prev = 0;
+                int curr = 0;
+                int begin = 0;
+                for (int k = 1; k < al.size(); k++) {
+                        curr = al.get(k);
+                        if(curr == s.length() - 1){
+                        }
+                        if (curr == prev + 1 && curr != s.length() - 1) {
+                                prev = curr;
+                        } else if(curr == prev + 1 &&  curr == s.length() - 1){
+                                strl.add(s.substring(begin, curr+1));
+                        }else {
+                                strl.add(s.substring(prev, curr));
+                                prev = curr;
+                                begin = curr;
+                                if (k == al.size() - 1) {
+                                        strl.add(s.substring(curr, s.length()));
+                                }
+                        }
+                }
+                return depilerChaineListee(strl, " ");
+        }
+        private static String depilerChaineListee(Vector<String> strl, String separateur) {
+                String s = "";
+                for(int i = 0; i < strl.size(); i++) {
+                        s += strl.get(i);
+                        if(i != strl.size() - 1) {
+                                s += separateur;
+                        }
+                }
+                return s;
+        }
+        public static Map<String, ChampEtendu> trierListeChampsEtendus(Map<String, ChampEtendu> listeChampsEtendus) {
+                List<String> tmp = new ArrayList<String>(listeChampsEtendus.keySet());
+                Collections.sort(tmp, new Comparator<String>() {
+                    @Override
+                    public int compare(String arg0, String arg1) {
+                        return arg0.compareTo(arg1);
+                    }
+                });
+                return listeChampsEtendus;
+        }
+        /**
+         * Solution issue de stackoverflow :
+         * http://stackoverflow.com/questions/1143951/what-is-the-simplest-way-to-convert-a-java-string-from-all-caps-words-separated
+         */
+        public static String convertirEnChaMot(String s) {
+                s = s.replaceAll("_", " ");
+                s = s.replaceAll("-", " ");
+                String[] parties = s.split(" ");
+                String chaineChaMot = "";
+                for (String partie : parties){
+                        chaineChaMot = chaineChaMot + convertirMotEnChaMot(partie);
+                }
+                return chaineChaMot;
+        }
+        protected static String convertirMotEnChaMot(String s) {
+                // MiaOu
+                return s.substring(0, 1).toUpperCase() +
+                       s.substring(1).toLowerCase();
+        }
+        public static void curseurAttente() {
+            RootPanel.getBodyElement().getStyle().setProperty("cursor", "wait");
+        }
+        public static void curseurParDefaut() {
+                RootPanel.getBodyElement().getStyle().setProperty("cursor", "default");
+        }
+        public static Map<String, String> parserRetourReferentielPerso(Response response) {
+                final Map<String, String> referentielData = new HashMap<String, String>();
+                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();
+                        for (int i = 0; i < taillemax; i++) {
+                                if ((elementsRef = reponse.get(i).isString()) != null) {
+                                        String valeur = elementsRef.stringValue();
+                                        referentielData.put(i+"", valeur);
+                                }
+                        }
+                }
+                return referentielData;
+        }
+        public static Map<String, ReferentielNom> parserRetourReferentielNomIndexeParNom(Response response) {
+                final Map<String, ReferentielNom> 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 HashMap<String, ReferentielNom>(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.getNom(),nomScientifique);
+                                }
+                        }
+                } else {
+                        referentielNomData = new HashMap<String, ReferentielNom>(0);
+                }
+                return referentielNomData;
+        }
+        public static Map<String, String> convertirListeReferentielNomVersMap(Map<String, ReferentielNom> referentielNom) {
+                Map<String, String> nomMap = new HashMap<String, String>();
+                for (Iterator<String> it  = referentielNom.keySet().iterator(); it.hasNext();) {
+                        String cle = it.next();
+                        nomMap.put(cle, referentielNom.get(cle).getNom());
+                }
+                return nomMap;
+        }
+        public static Map<String, ReferentielLocalite> parserRetourReferentielLocaliteIndexeParNom(Response response) {
+                final Map<String, ReferentielLocalite> referentielLocaliteData;
+                final JSONValue responseValue = JSONParser.parse(response.getText());
+                JSONArray reponse = null;
+                // si c'est un tableau
+                if ((reponse = responseValue.isArray()) != null) {
+                        JSONArray localites;
+                        final int taillemax = reponse.size();
+                        referentielLocaliteData = new HashMap<String, ReferentielLocalite>(taillemax);
+                        for (int i = 0; i < taillemax; i++) {
+                                if ((localites = reponse.get(i).isArray()) != null) {
+                                        String localite = ((JSONString) localites.get(0)).stringValue();
+                                        String codeLocalite  = ((JSONString) localites.get(1)).stringValue();
+                                        ReferentielLocalite com = new ReferentielLocalite(localite, codeLocalite);
+                                        referentielLocaliteData.put(com.getLocalite(), com);
+                                }
+                        }
+                } else {
+                        referentielLocaliteData = new HashMap<String, ReferentielLocalite>(0);
+                }
+                return referentielLocaliteData;
+        }
+        public static Map<String, String> convertirListeReferentielLocaliteVersMap(Map<String, ReferentielLocalite> referentielLocalite) {
+                Map<String, String> locMap = new HashMap<String, String>();
+                for (Iterator<String> it  = referentielLocalite.keySet().iterator(); it.hasNext();) {
+                        String cle = it.next();
+                        locMap.put(cle, referentielLocalite.get(cle).getLocalite());
+                }
+                return locMap;
+        }
+        public static Map<String, String> parserRetourImportObs(String json) {
+                final JSONValue responseValue = JSONParser.parse(json);
+                JSONObject reponse = null;
+                Map<String, String> retourImport = new HashMap<String,String>();
+                // si c'est un objet
+                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();
+                                retourImport.put(cle, valeur);
+                        }
+                }
+                return retourImport;
+        }
+        public static void envoyerRequeteStatsUpload(final Callback<String, String> cb) {
+                RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()
+                                +"/ImportXLS") ;
+                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) {
+                                        cb.onSuccess(response.getText());
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        public static native void  LogVersFirebug(Object o) /*-{
+                if (!!($wnd.console && $wnd.console.log)) {
+                        console.log(o);
+                }
+        }-*/;
+        public static 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;
+        }
+        public static String obtenirCodeLangueSysteme() {
+                String langueSystemeBrute = obtenirLangueSysteme();
+                // le navigateur peut éventuellement renvoyer une chaine de la forme
+                // en-us ou fr-fr par exemple
+                String[] lngTab = langueSystemeBrute.split("-");
+                return (lngTab.length > 0) ? lngTab[0] : null;
+        }
+        public static native String obtenirLangueSysteme()  /*-{
+                lang = "";
+                if (!!($wnd.navigator && $wnd.navigator.language)) {
+                        lang = window.navigator.language;
+                }
+                return lang;
+        }-*/;
+        public static native String utf8ToB64(String str) /*-{
+                return window.btoa(unescape(encodeURIComponent( str )));
+        }-*/;
+        public static native String b64ToUtf8(String str) /*-{
+                return decodeURIComponent(escape(window.atob( str )));
+        }-*/;
+}

 /trunk/src/org/tela_botanica/client/CarnetEnLigneMediateur.java
 New file
 ,0 → 1,498
+package org.tela_botanica.client;
+import org.tela_botanica.client.i18n.Msg;
+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= Msg.get("cel-utilisation")+", <u>"+Msg.get("identifiez-vous")+"</u> "+Msg.get("pour-transmettre-tela");
+        /**
+         * 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);
+                // 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(Msg.get("question-import-anonyme-connecte")+" ?")) {
+                                                  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(Msg.get("question-import-anonyme-connecte")+" ?")) {
+                                          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[] paramsU = {Utilisateur.getInstance().getLoginUtilisateurConsulte()};
+                String labelAdmin = "<div id=\"lienAdmin\"> "+Msg.get("admin-consulter-donnees", paramsU)+" <a id=\"LienChangerUtilisateur\" href=\"#\">"+Msg.get("changer-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();
+        }-*/;
+}

 /trunk/src/org/tela_botanica/client/i18n/I18n.java
 New file
 ,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 Msg getMessages() {
+                return (Msg) GWT.create(Msg.class);
+        }
+}

 /trunk/src/org/tela_botanica/client/i18n/VocabulaireMetadonnees.java
 New file
 ,0 → 1,22
+package org.tela_botanica.client.i18n;
+import com.google.gwt.i18n.client.Dictionary;
+public class VocabulaireMetadonnees  {
+        private static Dictionary traductionMetadonnees = null;
+        public static String getTraduction(String terme) {
+                traductionMetadonnees = Dictionary.getDictionary("traductionMetadonnees_"+Msg.getLangue());
+                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;
+        }
+}

 /trunk/src/org/tela_botanica/client/i18n/Msg.java
 New file
 ,0 → 1,223
+package org.tela_botanica.client.i18n;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import com.google.gwt.i18n.client.Dictionary;
+import java.lang.Exception;
+import java.util.ArrayList;
+import java.util.List;
+/**
+ * Gère l'internationalisation
+ */
+public class Msg {
+        public static final String MESSAGE_INEXISTANT = "N/A";
+        /** langue en cours */
+        protected static String langue;
+        /** langue par défaut */
+        protected static String langueDefaut;
+        /** langues disponibles */
+        protected static List<String> languesDisponibles;
+        /**
+         * Initialisation - à appeler une fois avant tout utilisation
+         * @return true si tout s'est bien passé, false sinon
+         */
+        public static boolean init() {
+                // lire la config pour obtenir les langues
+                languesDisponibles = parserLanguesDisponibles(Configuration.getLanguesDisponibles());
+                // lire la config et charger la langue par défaut
+                langueDefaut = Configuration.getLangueDefaut();
+                // si la langue par défaut n'existe pas, on arrête tout
+                return setLangue(langueDefaut);
+        }
+        /**
+         * Initialisation - raccourci pour initialiser avec une langue
+         * @param langue la langue à définir jusqu'à nouvel ordre
+         * @return true si tout s'est bien passé, false sinon
+         */
+        public static boolean init(String langue) {
+                boolean ok = false;
+                if (init()) {
+                        ok = setLangue(langue);
+                }
+                return ok;
+        }
+        /**
+         * [Re]définit la langue en cours
+         * @param langue
+         * @return true si la langue a été correctement définie, false
+         *                      sinon (si la langue n'est pas disponible)
+         */
+        public static boolean setLangue(String langue) {
+                boolean ok = false;
+                if (langueEstDisponible(langue)) { // on peut désactiver une langue même si le dictionnaire existe
+                        String nomDictionnaire = "messages_" + langue;
+                        try {
+                                Dictionary.getDictionary(nomDictionnaire);
+                                Msg.langue = langue;
+                                ok = true;
+                        } catch (Exception e) {}
+                }
+                return ok;
+        }
+        /**
+         * Retourne true si la langue demandée est disponible
+         * (ceci se fait via la valeur de config, peu importe, si le dictionnaire
+         * associé existe ou non)
+         *
+         * @param langue
+         * @return true si la langue est disponible, false sinon
+         */
+        public static boolean langueEstDisponible(String langue) {
+                return languesDisponibles.contains(langue);
+        }
+        /**
+         * Retourne la langue actuellement définie; si on a essayé de définir
+         * une langue qui n'est pas disponible, retournera la langue par défaut
+         *
+         * @return la langue actuellement définie
+         */
+        public static String getLangue() {
+                return langue;
+        }
+        /**
+         * @return la langue par défaut, définie dans la configuration
+         */
+        public static String getLangueDefaut() {
+                return langueDefaut;
+        }
+        /**
+         * @return les langues disponibles, définies dans la configuration
+         */
+        public static List<String> getLanguesDisponibles() {
+                return languesDisponibles;
+        }
+        /**
+         * Retourne un message dans la langue en cours
+         * @param cle
+         * @return
+         */
+        public static String get(String cle) {
+                return get(cle, langue);
+        }
+        /**
+         * Retourne un message dans la langue en cours,
+         * avec la première lettre en majuscule
+         * @param cle
+         * @return
+         */
+        public static String Get(String cle) {
+                return Get(cle, langue);
+        }
+        /**
+         * Retourne un message paramétré dans la langue en cours
+         * @param cle
+         * @param[] params
+         * @return
+         */
+        public static String get(String cle, String[] params) {
+                return get(cle, langue, params);
+        }
+        /**
+         * Retourne un message paramétré dans la langue en cours,
+         * avec la première lettre en majuscule
+         * @param cle
+         * @param[] params
+         * @return
+         */
+        public static String Get(String cle, String[] params) {
+                return Get(cle, langue, params);
+        }
+        /**
+         * Retourne un message dans la langue demandée; s'il n'est pas trouvé, le cherche
+         * dans la langue par défaut; en cas d'échec, retourne un terme générique d'avertissement
+         * @param cle l'identifiant du message demandé
+         * @param langue la langue dans laquelle on souhaite l'obtenir
+         * @return le message dans la langue en cours s'il existe, sinon le
+         *                      message dans la langue par défaut s'il existe, sinon la
+         *                      chaîne définie dans Msg.MESSAGE_INEXISTANT
+         */
+        public static String get(String cle, String langue) {
+                String nomDictionnaire = "messages_" + langue;
+                String message;
+                try {
+                        message = Dictionary.getDictionary(nomDictionnaire).get(cle);
+                } catch (Exception e) {
+                        try {
+                                message = Dictionary.getDictionary("messages_" + langueDefaut).get(cle);
+                        } catch (Exception me) {
+                                message = Msg.MESSAGE_INEXISTANT;
+                        }
+                }
+                return message;
+        }
+        /**
+         * Comme get(String cle, String langue), mais retourne le message
+         * avec la première lettre en majuscule
+         * @param cle
+         * @param langue
+         * @return
+         */
+        public static String Get(String cle, String langue) {
+                String message = get(cle, langue);
+                return message.substring(0,1).toUpperCase() + message.substring(1);
+        }
+        /**
+         * Retourne un message paramétré dans la langue demandée
+         * @param cle
+         * @param langue
+         * @param[] params
+         * @return
+         */
+        public static String get(String cle, String langue, String[] params) {
+                String message = get(cle, langue);
+                for (int i = 0; i < params.length; i++) {
+                        message = message.replace("{"+i+"}", params[i]);
+                }
+                return message;
+        }
+        /**
+         * Comme get(String cle, String langue, String[] params), mais retourne le
+         * message avec la première lettre en majuscule
+         * @param cle
+         * @param langue
+         * @param params
+         * @return
+         */
+        public static String Get(String cle, String langue, String[] params) {
+                String message = get(cle, langue, params);
+                return message.substring(0,1).toUpperCase() + message.substring(1);
+        }
+        /**
+         * Convertit la chaine de config de langues en un objet de type liste
+         * @param languesDisponibles la chaine de config
+         * @return List<String> une liste des langues disponibles
+         */
+        private static List<String> parserLanguesDisponibles(String languesDisponibles) {
+                ArrayList<String> langues = new ArrayList<>();
+                String[] languesTab = languesDisponibles.split(",");
+                for (int i = 0; i < languesTab.length; i++) {
+                        langues.add(languesTab[i]);
+                }
+                return langues;
+        }
+}

 /trunk/src/org/tela_botanica/client/image/ImageMediateur.java
 New file
 ,0 → 1,1877
+package org.tela_botanica.client.image;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.cel2;
+import org.tela_botanica.client.i18n.Msg;
+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.core.SortDir;
+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.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(Msg.get("details-images-obs"));
+        /**
+         * 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(Msg.get("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(Msg.get("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);
+        }
+         /** envoie au modèle une demande de mise a jour
+         *
+         * @param r
+         *            la vue demandeuse de mise a jour
+         */
+        public void obtenirPhotoGalerieSansCalculerPages(Rafraichissable r) {
+                masquerChargement();
+                getIModele().obtenirPhotoGalerie(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) {
+                rafraichirArbreMotsClesFiltre(arbreMC);
+                metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false);
+                if(fnMc != null) {
+                        fnMc.rafraichir(arbreMC, false);
+                }
+        }
+        public void rafraichirArbreMotsClesFiltre(Tree arbreMc) {
+                filtres.getMotsClesFiltre().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(Msg.get("message-envoi-images-identifie"))) {
+                                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);
+                        obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), imgNum);
+                        obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum);
+                }
+                obtenirMotsClesId(fnMc, 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(Msg.get("indication-supprimer-images")+" ?")) {
+                                masquerChargement();
+                                getIModele().supprimerImages(ids);
+                                aucuneSelection();
+                        }
+                } else {
+                        Window.alert(Msg.get("message-suppression-images-impossible"));
+                }
+        }
+        /**
+         * 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(Msg.get("ajouter-mot-cle"));
+                final com.gwtext.client.widgets.menu.Item renommerN = new Item(Msg.get("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, Rafraichissable r) {
+                getIModele().ajouterMotCleDansArbre(n, arbreMC, r);
+                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, Rafraichissable r) {
+                getIModele().supprimerMotCleDansArbre(n, arbreMC, r);
+                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, Rafraichissable r) {
+                getIModele().modifierMotCleDansArbre(n, arbreMC, r);
+                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, Rafraichissable r) {
+                getIModele().deplacerMotCleDansArbre(n, arbreMC, r);
+                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(Msg.get("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);
+                String[] stParams = {ids.length+""};
+                Window.alert(Msg.get("nb-images-ajoutees-tampon", stParams));
+        }
+        /**
+         * Affiche les ids des images contenues dans le tampon
+         */
+        public void afficherIdSelectionImages() {
+                Window.alert(Msg.get("contenu-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(Msg.get("tampon-a-ete-vide"));
+        }
+        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 = rddrop.getAsString("id_obs")+"," ;
+                        String message = "";
+                        idObss = rddrop.getAsString("id_obs")+",";
+                        message = Msg.get("question-lier-images-obs-sel")+" ?";
+                        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 = Msg.get("question-lier-obs-image-point")+" ?";
+                        } else {
+                                message = Msg.get("question-lier-obs-images-sel")+" ?";
+                        }
+                        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(Msg.get("tampon-vide"));
+                        return ;
+                }
+                if(obsRec.length == 0)
+                {
+                        Window.alert(Msg.get("aucune-obs-selectionnee")) ;
+                        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(Msg.get("aucune-image-selectionnee")) ;
+                        return ;
+                } else {
+                        for (int i = 0; i < idsImg.length; i++) {
+                                String idEncours = iModele.obtenirIdPourOrdre(idsImg[i]);
+                                selectionImages += idEncours + ",";
+                        }
+                }
+                if(obsRec.length == 0)
+                {
+                        Window.alert(Msg.get("aucune-obs-selectionnee")) ;
+                        return ;
+                } else  {
+                        for(int i =0 ; i< obsRec.length ; i++)
+                        {
+                                idsObs += obsRec[i].getAsString("id_obs")+"," ;
+                        }
+                }
+                String message = Msg.get("question-lier-obs-sel-images-sel")+" ?";
+                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(Msg.get("question-supprimer-lien-images-obs")+" ?"))
+                {
+                        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, fnMc);
+                        }
+                        @Override
+                        protected void surDeplacementMotCle(TreeNode node, Tree arbre) {
+                                deplacerMotCleDansArbre(node, arbre, fnMc);
+                        }
+                        @Override
+                        protected void surClicValider(String chaineMotsCles, Tree arbre) {
+                                mettreAjourMotsCles(chaineMotsCles, arbre);
+                        }
+                        @Override
+                        protected void surChangementTexte(TreeNode node, Tree arbre) {
+                                modifierMotCleDansArbre(node, arbre, fnMc);
+                        }
+                        @Override
+                        protected void surAjoutMotCle(TreeNode node, Tree arbre) {
+                                ajouterMotCleDansArbre(node, arbre, fnMc);
+                        }
+                        @Override
+                        protected void surAffichageMenuContextuel(TreeNode node, EventObject e,
+                                        TreeEditor te) {
+                                montrerContextMenuArbre(node, e, te);
+                        }
+                        @Override
+                        protected void demanderArbreMotsCles(Rafraichissable r) {
+                                ImageMediateur.this.obtenirArbreMotsCles(r);
+                        }
+                        protected void surRetourWebService(Tree arbreMc) {
+                                rafraichirArbreMotsClesFiltre(arbreMc);
+                        }
+                };
+                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();
+                String[] ids = getVueSelectionnee().getIdSelectionnees();
+                if(ids.length > 0) {
+                        obtenirMotsClesId(fnMc, ids[ids.length - 1]);
+                }
+        }
+        public String getTri() {
+                // centralise le tri suivant la vue active
+                // pour le moment seule la liste est triable
+                return listeImage.renvoyerTri();
+        }
+        public String getDirectionTri() {
+                // centralise la direction de tri suivant la vue active
+                return listeImage.renvoyerDirectionTri();
+        }
+        public static FieldDef[] getDefinitionsChampsGrilleImages() {
+                // creation du store
+                FieldDef defNumImage = new IntegerFieldDef("num_image");
+                FieldDef defNomImage = new StringFieldDef("nom_original");
+                FieldDef defDatImage = new StringFieldDef("dat_image");
+                FieldDef defLieImage = new StringFieldDef("lie_image");
+                FieldDef defAppImage = new StringFieldDef("app_image");
+                FieldDef defUrlImageS = new StringFieldDef("url_image_S");
+                FieldDef defUrlImageM = new StringFieldDef("url_image_M");
+                FieldDef defUrlImage = new StringFieldDef("url_image");
+                FieldDef defNoteImage = new StringFieldDef("note_image");
+                FieldDef defidImage = new StringFieldDef("id_image");
+                FieldDef defTailleX = new IntegerFieldDef("taille_x");
+                FieldDef defTailleY = new IntegerFieldDef("taille_y");
+                FieldDef defObsAssociees = new StringFieldDef("obs_associees");
+                FieldDef defTransmis = new StringFieldDef("transmis");
+                FieldDef[] defTab = { defNumImage, defNomImage, defDatImage, defLieImage,
+                                defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
+                                defNoteImage, defidImage, defTailleX, defTailleY, defObsAssociees, defTransmis};
+                return defTab;
+        }
+        public String getTriMiniListeObs() {
+                return metadonneesIptcExif.getMiniListeObservation().renvoyerTri();
+        }
+        public String getDirectionTriMiniListeObs() {
+                return metadonneesIptcExif.getMiniListeObservation().renvoyerDirectionTri();
+        }
+}

 /trunk/src/org/tela_botanica/client/image/ImageModele.java
 New file
 ,0 → 1,959
+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 org.tela_botanica.client.util.MotsClesUtilitaire;
+import com.google.gwt.json.client.JSONArray;
+import com.google.gwt.user.client.Window;
+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.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;
+        }
+        public String[][] obtenirFiltresPourComptage() {
+                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];
+                }
+                return criteres;
+        }
+        public String[][] obtenirFiltresPourDonnees() {
+                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];
+                }
+                return valeursFiltres;
+        }
+        /**
+         * 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[][] criteres = obtenirFiltresPourComptage();
+                // 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 + 4][2];
+                String[] tri = { "tri", "" + getIMediateur().getTri() };
+                String[] triDir = { "dir", "" + getIMediateur().getDirectionTri()};
+                String[] limite = { "limite", "" + taillePage };
+                String[] taillePage = { "numero_page", "" + pageEncours };
+                criteres2[0] = limite;
+                criteres2[1] = taillePage;
+                criteres2[2] = tri;
+                criteres2[3] = triDir;
+                for (int i = 0; i < valeursFiltres.length; i++) {
+                        criteres2[i + 4] = 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()][14];
+                        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();
+                                photoData[i][13] = im.getIdsObsAssociees();
+                                i++;
+                        }
+                        RecordDef rd = new RecordDef(ImageMediateur.getDefinitionsChampsGrilleImages());
+                        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();
+                        // 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 donneesArbre = (JSONArray)nouvelleDonnees;
+                        Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Tags", "racine", donneesArbre, false);
+                        arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
+                        motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
+                        // 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);
+                }
+        }
+        /**
+         * 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                mettreAjourMotsClesId(motCle, id);
+                String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
+                                + motCle + "&id=" + id + "&parent=" + parentId;
+                MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
+                String[] usObj = (String[]) n.getUserObject();
+                String id = usObj[1];
+                MCDao.supprimerBaseDeDonnees(id, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.modifierBaseDeDonnees(motCleModifie, r);
+        }
+        /**
+         * 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, Rafraichissable r) {
+                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();
+                        if(!parentUsObj[1].equals("racine")) {
+                                parentId = parentUsObj[1];
+                        }
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.deplacerBaseDeDonnees(motCleModifie, r);
+        }
+        /**
+         * 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[] tri = { "tri", "" + getIMediateur().getTriMiniListeObs() };
+                String[] triDir = { "tri_dir", "" + getIMediateur().getDirectionTriMiniListeObs()};
+                String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}, tri, triDir} ;
+                // 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();
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
 New file
 ,0 → 1,426
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.i18n.Msg;
+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 org.tela_botanica.client.util.MotsClesUtilitaire;
+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(Msg.get("tags"));
+                root.setId("racine"+prefixe);
+                String[] usObject = {Msg.get("mots-cles"), "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
+                        MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
+                                        .getRootNode(), false);
+                        // 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;
+        }
+        /**
+         * 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(Msg.get("tags"));
+                        root.setId("racine"+prefixe);
+                        String[] usObject = {Msg.get("mots-cles"), "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();
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/FenetreLicenceVue.java
 New file
 ,0 → 1,112
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("valider"));
+                private Button annulerAcceptationLicence = new Button(Msg.get("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 = Msg.get("licence");
+            public FenetreLicenceVue(CarnetEnLigneMediateur cm) {
+               super();
+               this.cm = cm;
+               setTitle(Msg.get("acceptation-licence"));
+               Panel conteneurHtml = new Panel();
+               conteneurHtml.setHeight(230);
+               conteneurHtml.setAutoScroll(true);
+               HTML conteneurLicence = new HTML();
+               conteneurHtml.add(conteneurLicence);
+               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("   "+Msg.get("lu-accepte-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
+                }
+}

 /trunk/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java
 New file
 ,0 → 1,106
+package org.tela_botanica.client.vues.observation;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("rendre-publiques-selectionnees"));
+                addItem(transmettreObservation);
+                deTransmettreObservation = new Item(Msg.get("rendre-privees-selectionnees"));
+                addItem(deTransmettreObservation);
+                supprimerObservation = new Item(Msg.get("supprimer-selectionnees"));
+                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

 /trunk/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java
 New file
 ,0 → 1,430
+package org.tela_botanica.client.vues.observation;
+import org.tela_botanica.client.i18n.Msg;
+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 valeurLocalite = "Bourges"; // j'aurais préféré Bort-les-Orgues
+        LatLng centreFrance = null;
+        LatLng pointLocalite = null;
+        String codeLoc = "";
+        String pays = "";
+        int niveauZoom = 6;
+        Label panneauExplication = new Label(Msg.get("explication-panneau-carto"));
+        private InfoWindow info;
+        private boolean zoomerSurRetour = false;
+        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(Msg.get("recherche-coordonnees-localite"));
+                        } else {
+                                panneauCarto.getEl().unmask();
+                        }
+                }
+        }
+        public void obtenirInfosLocalites(LatLng coord) {
+                // Remise à zéro des infos restantes d'une ancienne requete
+                valeurLocalite = "";
+                codeLoc = "";
+                pays = "";
+                oMediateur.obtenirInformationCoord(this, coord.lat(), coord.lng());
+        }
+        public void mettreAJourInfos(final LatLng pointNouvelleLocalite, int zoom) {
+                GoogleMap mapNulle = null;
+                if(nmk != null) {
+                        nmk.setMap(mapNulle);
+                }
+                pointLocalite = pointNouvelleLocalite;
+                nmk = fabriquerMarqueur(pointLocalite);
+                nmk.setMap(map);
+                afficherInfoMarker(nmk, construireContenuInfoMarker(nmk));
+                recentrerCarte(nmk.getPosition());
+                map.setZoom(zoom);
+        }
+        private void initialiserCarte(boolean localite) {
+                panneauCarto.clear();
+                centreFrance = LatLng.create(47.0504, 2.2347);
+                pointLocalite = 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(!localite) {
+                        fabriquerMarqueurIndication();
+                }
+                map.addClickListener(new ClickHandler() {
+                        @Override
+                        public void handle(MouseEvent event) {
+                                obtenirInfosLocalites(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(pointLocalite);
+                nmk.setMap(map);
+                info.setContent("<div id=\"info_contenu\">"+
+                                Msg.get("deplacez-marqueur-pour-localiser") + "<br/>"
+                                +"longitude="
+                                + Util.tronquerNombrePourAffichage("" + nmk.getPosition().lng(), 5) + "<br />latitude="
+                                + Util.tronquerNombrePourAffichage("" + nmk.getPosition().lat(), 5) + "</div>");
+                infoOuverte = true;
+                info.open(map,nmk);
+        }
+        public void AfficherMessageAucuneInfos() {
+                mettreAJourInfos(centreFrance, niveauZoom);
+                Window.alert(Msg.get("aucune-information"));
+        }
+        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 infosLocalite = new EntiteGeographiqueObservation(codeLoc,valeurLocalite,null,null);
+                                        infosLocalite.setPays(pays);
+                                        infosLocalite.setLat(pointLocalite.lat()+"");
+                                        infosLocalite.setLon(pointLocalite.lng()+"");
+                                        oMediateur.rafraichirSaisieLocaliteObservation(infosLocalite);
+                                }
+                        });
+                        bouton.focus();
+                }
+        }
+        @Override
+        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
+                // rétablissement du curseur, parfois mis sur "attente" par le processus chargeant la carte
+                Util.curseurParDefaut();
+                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);
+                        // si on a un point, on zoome fort dès le début
+                        if (zoomerSurRetour) {
+                                niveauZoom = 16;
+                                zoomerSurRetour = false;
+                        } else if (infos.getZoom() > 0) {
+                                niveauZoom = infos.getZoom();
+                        }
+                        String nouvelleValeurLocalite = infos.getZoneGeo();
+                        valeurLocalite = nouvelleValeurLocalite;
+                        codeLoc = "";
+                        if(infos.getIdZoneGeo() != null) {
+                                // Quoi stocker pour en dehors de la france ?
+                                if (infos.getPays().equals("FR")) {
+                                        codeLoc = Util.convertirChaineZoneGeoVersDepartement(infos.getIdZoneGeo());
+                                } else {
+                                        codeLoc = infos.getPays();
+                                }
+                        }
+                        pays = infos.getPays();
+                        pointLocalite = coord;
+                        mettreAJourInfos(coord, niveauZoom);
+                }
+                masquerChargement(false);
+        }
+        public Marker fabriquerMarqueur(LatLng pointMarqueur) {
+                // 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) {
+                                afficherInfoMarker(marker, construireContenuPartielInfoMarker(marker));
+                                obtenirInfosLocalites(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, construireContenuPartielInfoMarker(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 String construireContenuInfoMarker(Marker marker) {
+                final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>";
+                String contenuMarker = "";
+                if(valeurLocalite == null || valeurLocalite.trim().equals("")) {
+                        if(marker.getPosition().lng() == 0 && marker.getPosition().lat() == 0) {
+                                LatLng point = centreFrance;
+                                marker.setPosition(point);
+                                niveauZoom = 6;
+                        }
+                        contenuMarker =
+                        "<div id=\"info_contenu\">"+
+                                Msg.get("aucun-lieu-trouve") + " <br/>"
+                                +Msg.get("deplacez-marqueur-pour-localiser") + " <br />"
+                                +"longitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lng(), 5)+"<br />"
+                                +"latitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lat(), 5)+
+                        "</div>";
+                } else {
+                        String chaineLocalite = valeurLocalite + ((codeLoc.isEmpty()) ? "" : " ("+codeLoc+")");
+                        contenuMarker =
+                        "<div id=\"info_contenu\">"+
+                                        chaineLocalite+"<br />"
+                                        +"longitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lng(), 5)+"<br />"
+                                        +"latitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lat(), 5)+
+                        "</div>";
+                }
+                return contenuMarker+ htmlBoutonOk;
+        }
+        public String construireContenuPartielInfoMarker(Marker marker) {
+                final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>";
+                String contenuMarker = "";
+                contenuMarker =
+                        "<div id=\"info_contenu\">"+
+                                        "<div class=\"recherche_infos_zone_geo\">"+
+                                                "<div class=\"recherche_infos_zone_geo_en_cours\">"+
+                                                        "<img src=\"chargement_carte.gif\" />"+
+                                                        "<div>"+
+                                                                Msg.get("recherche-nom-lieu") + "<br />"+
+                                                                Msg.get("prendre-un-moment") +
+                                                        "</div>"+
+                                                        "<hr class=\"nettoyage\" />"+
+                                                "</div>"+
+                                                Msg.get("que-les-coordonnees") +
+                                        "</div>"+
+                                        "longitude="+Util.tronquerNombrePourAffichage("" + marker.getPosition().lng(), 5)+"<br />"+
+                                        "latitude="+Util.tronquerNombrePourAffichage("" + marker.getPosition().lat(), 5)+
+                        "</div>";
+                return contenuMarker+ htmlBoutonOk;
+        }
+        public void afficherInfoMarker(Marker marker, String contenuInfo) {
+                info.setContent(contenuInfo);
+                info.open(map, marker);
+                pointLocalite = marker.getPosition();
+                info.addDomReadyListenerOnce(new InfoWindow.DomReadyHandler() {
+                        @Override
+                        public void handle() {
+                                ajouterListenerBouton("okMap");
+                        }
+                });
+                recentrerCarte(marker.getPosition());
+        }
+        public void afficherCarteEnAttenteAvecMarker(double lat, double lon) {
+                pointLocalite = LatLng.create(lat, lon);
+                nmk.setPosition(pointLocalite);
+                afficherInfoMarker(nmk, construireContenuPartielInfoMarker(nmk));
+        }
+        public double[] getCoordsCentreFrance() {
+                double[] coords = {47.0504, 2.2347};
+                return coords;
+        }
+        public void setDoitZoomerSurRetour(boolean b) {
+                zoomerSurRetour  = b;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java
 New file
 ,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

 /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java
 New file
 ,0 → 1,682
+package org.tela_botanica.client.vues.observation.filtres;
+import java.util.Comparator;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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
+         */
+        /**
+         * 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(Msg.get("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(Msg.get("dates"));
+                                root.setId("racine_date");
+                                String[] usObject = { Msg.get("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(Msg.get("dates"));
+                                String[] usObjRoot = { Msg.get("dates"), Msg.get("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=Msg.get("inconnue") ;
+                                }
+                                if(jour.contains("00")) {
+                                        jour=Msg.get("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=Msg.get("inconnue") ;
+                        }
+                        if(jour.contains("00") || jour.equals(null)) {
+                                jour=Msg.get("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 Msg.get("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(Msg.get("dates"));
+                root.setId("racine_date");
+                String[] usObject = { Msg.get("dates"), Msg.get("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

 /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java
 New file
 ,0 → 1,785
+package org.tela_botanica.client.vues.observation.filtres;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Filtrable;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import org.tela_botanica.client.util.MotsClesUtilitaire;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.NodeTraversalCallback;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.dd.DragData;
+import com.gwtext.client.dd.DragDrop;
+import com.gwtext.client.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;
+                private String cheminTemporaireAjout = null;
+                public Rafraichissable thisRafraichissable;
+                /**
+                 * 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(Msg.get("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(Msg.get("projets"));
+                                        root.setId("racine_obs");
+                                        String[] usObject = { Msg.get("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(Msg.get("ajouter-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) {
+                                        if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
+                                                te.startEdit(node);
+                                                String[] params = { MotsClesUtilitaire.getChaineCaracteresInterdits() };
+                                                Window.alert(Msg.get("mot-cle-non-vide", params));
+                                                return;
+                                        }
+                                        if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
+                                                te.startEdit(node);
+                                                Window.alert(Msg.get("mot-cle-existe-deja"));
+                                                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) {
+                                                ajouterMotCleDansArbreMediateur(nd);
+                                        }
+                                        // si c'est noeud déjà existant
+                                        else {
+                                                if (modifNoeud) {
+                                                        modifierMotCleDansArbreMediateur(nd);
+                                                }
+                                        }
+                                        //arbreMotsCles.disable();
+                                }
+                                @Override
+                                public boolean doBeforeMoveNode(Tree tree, TreeNode node,
+                                                TreeNode oldParent, TreeNode newParent, int index) {
+                                        boolean ok = true;
+                                        if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
+                                                ok = false;
+                                                Window.alert(Msg.get("mot-cle-existe-deja"));
+                                        }
+                                        return ok;
+                                }
+                                @Override
+                                public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
+                                                DragData dragData, String point, DragDrop source,
+                                                TreeNode dropNode) {
+                                        boolean ok = true;
+                                        if(dragData instanceof TreeDragData) {
+                                                ok = MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
+                                        }
+                                        return ok;
+                                }
+                                // 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);
+                                }
+                        });
+                }
+                private void ajouterMotCleDansArbreMediateur(TreeNode nd) {
+                        // on notifie le médiateur de l'ajout et on lui passe
+                        // l'arbre
+                        getOMediateur().ajouterMotCleDansArbre(nd,
+                                        getArbreMotsCles().getTree(), this);
+                        // et considère l'ajout achevé
+                        ajoutNoeud = false;
+                }
+                private void modifierMotCleDansArbreMediateur(TreeNode nd) {
+                        // 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;
+                }
+                /**
+                 * 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(Msg.get("confirmer-suppression-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(), this);
+                                }
+                        } else {
+                                // si l'utilisateur tente de supprimer la racine, on l'avertit de
+                                // son erreur
+                                Window.alert(Msg.get("impossible-supprimer-racine"));
+                        }
+                }
+                /**
+                 * Ajoute un noeud dans l'arbre au parent donné
+                 *
+                 * @param parent
+                 *            le futur parent du noeud à ajouter
+                 */
+                public void ajouterNoeud(TreeNode parent) {
+                        if(parent == null) {
+                                parent = arbreMotsCles.getRootNode();
+                        }
+                        ajoutNoeud = true;
+                        TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);
+                        // on le concatène au parent et on étend ses enfants
+                        parent.appendChild(nd);
+                        parent.expand();
+                        cheminTemporaireAjout = nd.getId();
+                        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) {
+                        if(getArbreMotsCles().getNodeById(motCleId) != null) {
+                                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) {
+                        arbreMotsCles.enable();
+                        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();
+                                }
+                                MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), false);
+                                // 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;
+                                }
+                        }
+                        // reception d'un nouvel identifiant de mot clé
+                        if(nouvelleDonnees instanceof Integer) {
+                                if(cheminTemporaireAjout != null) {
+                                        String id = ((Integer)(nouvelleDonnees)).toString();
+                                        TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
+                                        String[] userObj = {noeudEnAjout.getText(), id};
+                                        noeudEnAjout.setUserObject(userObj);
+                                        cheminTemporaireAjout = null;
+                                }
+                        }
+                }
+                public void raz() {
+                        arbreCharge = false ;
+                        arbreMotsCles.collapseAll();
+                        arbreMotsCles.clear() ;
+                        // on crée une racine pour l'arbre
+                        TreeNode root = new TreeNode(Msg.get("projets"));
+                        root.setId("racine_obs");
+                        String[] usObject = { Msg.get("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) {
+                                        String usObject[] = (String[]) noeuds[i]
+                                                        .getUserObject();
+                                        String nodeId = usObject[1];
+                                        val += ";"+nodeId;
+                                }
+                        }
+                        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(
+                                                Msg.get("ajouter-projet"));
+                                final com.gwtext.client.widgets.menu.Item suppN = new Item(
+                                                Msg.get("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

 /trunk/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java
 New file
 ,0 → 1,117
+package org.tela_botanica.client.vues.observation.filtres;
+import org.tela_botanica.client.i18n.Msg;
+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 = Msg.get("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(Msg.get("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 Msg.get("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 = "";
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java
 New file
 ,0 → 1,630
+package org.tela_botanica.client.vues.observation.filtres;
+import java.util.Comparator;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("localites"));
+                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(Msg.get("localites"));
+                                root.setId("racine_entite");
+                                String[] usObject = { Msg.get("localites") };
+                                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[] filtresStr = {"pays","departement","localite","lieudit","station"};
+                int profNoeud = node.getDepth();
+                if(profNoeud == 0) {
+                                if(!arbreCharge)
+                                {
+                                        arbreEntitesGeographiques.getRootNode().expand();
+                                }
+                                else
+                                {
+                                        observationMediateur.obtenirNombreObservation() ;
+                                }
+                } else {
+                        Node noeud = (Node)node;
+                        for(int i = profNoeud - 1; i >= 0; i--) {
+                                nomFiltre += filtresStr[i]+",";
+                                entitesGeographiquesEncours += ((String[])noeud.getUserObject())[0]+",";
+                                noeud = noeud.getParentNode();
+                        }
+                        nomFiltre.replaceAll(",$", "");
+                        entitesGeographiquesEncours.replaceAll(",$", "");
+                }
+                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(Msg.get("localites"));
+                                String[] usObjRoot = { Msg.get("localites") };
+                                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());
+                        ent.setPays(obs.getPays());
+                        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 Msg.get("localites");
+        }
+        /**
+         * 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(Msg.get("inconnue"))) {
+                                        return -1 ;
+                                }
+                                if(o2.getText().equals(Msg.get("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(Msg.get("localites"));
+                root.setId("racine_entite");
+                String[] usObject = { Msg.get("localites") };
+                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;
+                String id_pays = ent.getPays();
+                // 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_pays.equals(null) || (id_pays.trim()).isEmpty()) {
+                        id_pays=Msg.get("inconnue") ;
+                }
+                if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) {
+                        id_zone_geo=Msg.get("inconnue") ;
+                } else {
+                        if(ent.getIdZoneGeo().contains("INSEE-C:") && ent.getIdZoneGeo().length() > 10) {
+                                id_pays = "FR";
+                        }
+                }
+                if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) {
+                        zone_geo=Msg.get("inconnue") ;
+                }
+                if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
+                        lieuDit=Msg.get("inconnue") ;
+                }
+                if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) {
+                        station=Msg.get("inconnue") ;
+                }
+                String[] idLocalites = {id_pays, id_zone_geo, zone_geo, lieuDit, station};
+                Node noeudMemeId = null;
+                String idNoeud = "";
+                String locNiveau = "";
+                Node noeudParent = root;
+                for(int i = 0; i < idLocalites.length; i++) {
+                        // Recherche des noeuds correspondant à chacun des niveaux de la hierarchie
+                        locNiveau = idLocalites[i];
+                        idNoeud += idLocalites[i];
+                        noeudMemeId = arbre.getNodeById(idNoeud);
+                        // Si le noeud n'existe pas on le crée
+                        if(noeudMemeId == null) {
+                                noeudMemeId = creerNoeud(idNoeud, locNiveau);
+                                noeudParent.appendChild(noeudMemeId) ;
+                        }
+                        noeudParent = noeudMemeId;
+                }
+                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("pays")) {
+                        profondeur = 1;
+                }
+                if(nom.equals("departement")) {
+                        profondeur = 2;
+                }
+                if(nom.equals("localite")) {
+                        profondeur = 3;
+                }
+                if(nom.equals("lieudit")) {
+                        profondeur = 4;
+                }
+                if(nom.equals("station")) {
+                        profondeur = 5;
+                }
+                return profondeur;
+        }
+}
 Property changes:
 Added: svn:mergeinfo

 /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java
 New file
 ,0 → 1,85
+package org.tela_botanica.client.vues.observation.indicateurs;
+import org.tela_botanica.client.i18n.Msg;
+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 String refTax = "";
+        private String numTax = "";
+        private String efloreBaseUrl = "";
+        private Label titreLien = new Label(Msg.get("voir-fiche-eflore"));
+        public LienExterneVue(ObservationMediateur om) {
+                refTax = verifierEtFormaterReferentiel(om.getRefTaxSelectionne().getCode());
+                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) {
+                String[] nouvellesDonnees = (String[]) nouvelleDonnees;
+                String nouveauNumTax = nouvellesDonnees[0];
+                String codeRef = nouvellesDonnees[1];
+                if(nouveauNumTax.trim().equals("") || codeRef.trim().equals("autre") || nouveauNumTax.trim().equals("0") || codeRef.trim().equals("")) {
+                        titreLien.setVisible(false);
+                } else {
+                        if(!titreLien.isVisible()) {
+                                titreLien.setVisible(true);
+                        }
+                        numTax = nouveauNumTax;
+                        refTax = verifierEtFormaterReferentiel(codeRef);
+                }
+        }
+        public String verifierEtFormaterReferentiel(String refTax) {
+                // Sert simplement à exclure les vieux formats de référentiel
+                // du genre bdtfx:v2.00 ou bien bdnff.v1_01 etc...
+                // TODO: nettoyer également la base de données
+                String retour = refTax;
+                if(retour != null && !retour.isEmpty()) {
+                        if (retour.contains(":")) {
+                                retour = retour.split(":")[0];
+                        }
+                        if(retour.contains(".")) {
+                                retour = retour.split(".")[0];
+                        }
+                }
+                return retour;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java
 New file
 ,0 → 1,608
+package org.tela_botanica.client.vues.observation.indicateurs;
+import org.tela_botanica.client.i18n.Msg;
+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.HTML;
+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 = Msg.get("images-liees");
+        /**
+         * 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\"> " + Msg.get("double-clic-agrandir") + " </div>") ;
+        com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ;
+        Image imgAgrandie = null;
+        private HTML htmlVide = new HTML();
+        /**
+         * 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");
+                imageConteneur.add(htmlVide);
+                // 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) ;
+                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;
+                image.setVisible(false);
+                afficherImageSinonAfficherMessage(false);
+                // 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 ;
+                        afficherImageSinonAfficherMessage(true);
+                        afficherImage() ;
+                } else {
+                        afficherImageSinonAfficherMessage(false);
+                }
+        }
+        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);
+                }
+                if(infosImages != null && infosImages.length > 1) {
+                        prev.setEnabled(true);
+                        suiv.setEnabled(true);
+                } else {
+                        prev.setEnabled(false);
+                        suiv.setEnabled(false);
+                }
+        }
+        private void afficherImageSinonAfficherMessage(boolean afficherImage) {
+                if(afficherImage) {
+                        htmlVide.setVisible(false);
+                } else {
+                        setTitle(Msg.get("aucune-image-liee"));
+                        afficherHtmlVide();
+                }
+                image.setVisible(afficherImage);
+        }
+        private void afficherHtmlVide() {
+                String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-image-liee")+"</div>";
+                htmlVide.setHeight("150px");
+                htmlVide.setHTML(htmlDivVide);
+                htmlVide.setVisible(true);
+        }
+        /**
+         * 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(Msg.get("supprimer-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

 /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java
 New file
 ,0 → 1,214
+package org.tela_botanica.client.vues.observation.indicateurs;
+import org.tela_botanica.client.i18n.Msg;
+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.HTML;
+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 {
+        /**
+         * l'image à afficher
+         */
+        private Image image = new Image();
+        private String urlImage = "" ;
+        private HTML htmlVide = new HTML();
+        private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </div>") ;
+        com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("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) {
+                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);
+                add(htmlVide);
+                image.setPixelSize(150, 150);
+                afficherImageSinonAfficherMessage(false);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        private void afficherImageSinonAfficherMessage(boolean afficherImage) {
+                if(afficherImage) {
+                        htmlVide.setVisible(false);
+                } else {
+                        afficherHtmlVide();
+                }
+                image.setVisible(afficherImage);
+        }
+        private void afficherHtmlVide() {
+                String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-carte-taxon")+"</div>";
+                htmlVide.setHeight("150px");
+                htmlVide.setHTML(htmlDivVide);
+                htmlVide.setVisible(true);
+        }
+        /**
+         * 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) {
+                                afficherImageSinonAfficherMessage(false);
+                        }
+                        else {
+                                afficherImageSinonAfficherMessage(true);
+                                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

 /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java
 New file
 ,0 → 1,237
+package org.tela_botanica.client.vues.observation.indicateurs;
+import org.tela_botanica.client.i18n.Msg;
+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.HTML;
+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 HTML htmlVide = new HTML();
+        private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ;
+        private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </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) ;
+                htmlVide.setHeight("0px");
+                htmlVide.setVisible(false);
+                add(image);
+                add(htmlVide);
+                image.setPixelSize(150, 150);
+                image.sinkEvents(Event.ONDBLCLICK);
+                afficherImageSinonAfficherMessage(false);
+                // 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("")) {
+                                afficherHtmlVide();
+                                image.setVisible(false);
+                        }
+                        else {
+                                afficherImageSinonAfficherMessage(true);
+                                image.setUrl(urlImage);
+                                image.setPixelSize(150, 150);
+                                verifierEtRetaillerImage();
+                        }
+                } else {
+                        afficherImageSinonAfficherMessage(false);
+                }
+                observationMediateur.deMasquerChargementInfosObservations() ;
+        }
+        private void afficherImageSinonAfficherMessage(boolean afficherImage) {
+                if(afficherImage) {
+                        htmlVide.setVisible(false);
+                } else {
+                        afficherHtmlVide();
+                }
+                image.setVisible(afficherImage);
+        }
+        private void afficherHtmlVide() {
+                String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-image-taxon")+"</div>";
+                htmlVide.setHeight("150px");
+                htmlVide.setHTML(htmlDivVide);
+                htmlVide.setVisible(true);
+        }
+        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

 /trunk/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java
 New file
 ,0 → 1,174
+package org.tela_botanica.client.vues.observation;
+import java.util.Iterator;
+import java.util.Map;
+import org.tela_botanica.client.i18n.I18n;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import org.tela_botanica.client.util.Util;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.event.dom.client.ClickEvent;
+import com.google.gwt.event.dom.client.ClickHandler;
+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.HasHorizontalAlignment;
+import com.google.gwt.user.client.ui.Hidden;
+import com.google.gwt.user.client.ui.HorizontalPanel;
+import com.google.gwt.user.client.ui.ListBox;
+import com.google.gwt.user.client.ui.VerticalPanel;
+import com.google.gwt.user.client.ui.Widget;
+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 implements Rafraichissable {
+        private ObservationMediateur oMediateur = null;
+        private  Window nPan = null;
+        private Hidden identifiant = null;
+        private static ListeGroupesChampsEtendus cacheGroupes;
+        ListBox listeGroupeChampsEtendus;
+        public FormulaireImportObservationVue(ObservationMediateur om) {
+                this.oMediateur = om;
+                nPan = new Window(Msg.get("import-observations"));
+                identifiant = new Hidden();
+                identifiant.setName("utilisateur");
+                identifiant.setValue(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
+                final FormPanel form = new FormPanel();
+                final Button boutonValidation = new Button(Msg.get("envoyer"));
+                form.setEncoding(FormPanel.ENCODING_MULTIPART);
+                form.setMethod(FormPanel.METHOD_POST);
+                form.setWidth("450px");
+                nPan.setWidth("450px");
+                VerticalPanel holder = new VerticalPanel();
+                FileUpload upload = new FileUpload();
+                upload.setName("upload");
+                holder.add(upload);
+                holder.add(boutonValidation);
+                holder.add(identifiant);
+                listeGroupeChampsEtendus = new ListBox();
+                listeGroupeChampsEtendus.addStyleName("liste_projets_import");
+                if(cacheGroupes == null) {
+                        ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
+                        lrceDao.obtenirGroupesChampsEtendus(this);
+                } else {
+                        this.rafraichir(cacheGroupes, false);
+                }
+                HTML lienVersDocumentModele = new HTML("<a href=\"#\">" + Msg.get("telecharger-modele") + "</a>");
+                lienVersDocumentModele.addClickHandler(new ClickHandler() {
+                        @Override
+                        public void onClick(ClickEvent event) {
+                                String groupeimport = listeGroupeChampsEtendus.getValue(listeGroupeChampsEtendus.getSelectedIndex());
+                                String urlTplImport = Configuration.getServiceBaseUrl() + "/ImportXLS/template?groupe="+groupeimport;
+                                com.google.gwt.user.client.Window.open(urlTplImport, "", "");
+                        }
+                });
+                HorizontalPanel holHoriz = new HorizontalPanel();
+                holHoriz.add(lienVersDocumentModele);
+                holHoriz.add(listeGroupeChampsEtendus);
+                holder.add(holHoriz);
+                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) {
+                                // Certains client ne savent pas lire le retour d'upload correctement
+                                // notamment à cause des requêtes CORS, donc en cas de problème on
+                                // appelle manuellement les stats d'upload en lecture
+                                if(event.getResults() != null) {
+                                        try {
+                                                Map<String, String> retourImport = Util.parserRetourImportObs(event.getResults());
+                                                surRetourImport(retourImport);
+                                        } catch (Exception e) {
+                                                demanderStatsUpload();
+                                        }
+                                } else {
+                                        demanderStatsUpload();
+                                }
+                        }
+                });
+        }
+        private void demanderStatsUpload() {
+                Util.envoyerRequeteStatsUpload(new Callback<String, String>() {
+                        @Override
+                        public void onSuccess(String resultats) {
+                                Map<String, String> retourImport = Util.parserRetourImportObs(resultats);
+                                surRetourImport(retourImport);
+                        }
+                        @Override
+                        public void onFailure(String reason) {
+                                // TODO: rien à faire, si la requête échoue c'est que le serveur
+                                // ne répond pas et donc on a déjà eu des problèmes en amont
+                        }
+                });
+        }
+        private void surRetourImport(Map<String, String> retourImport) {
+                String message = "";
+                for (Iterator<String> iterator = retourImport.keySet().iterator(); iterator
+                                .hasNext();) {
+                        String indexRapport = iterator.next();
+                        // on ne met pas de "-" dans les clés json, mais par contre nos clé i18n
+                        // sont séparées par des tirets, donc on remplace
+                        String cleI18n = indexRapport.replace("_", "-");
+                        String[] StrParams = {retourImport.get(indexRapport).replace("\"", "")};
+                        message += Msg.get(cleI18n, StrParams)+"\n";
+                }
+                com.google.gwt.user.client.Window.alert(message);
+                nPan.close();
+                oMediateur.obtenirDernierePageObservation();
+        }
+        public void afficher() {
+                nPan.show();
+        }
+        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
+                if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) {
+                        cacheGroupes  = (ListeGroupesChampsEtendus)nouvelleDonnees;
+                        listeGroupeChampsEtendus.addItem(Msg.get("import-standard"), "");
+                        for (Iterator<String> iterator = cacheGroupes.getCorrespondancesCorrespondancesIdsNomsGroupes().keySet().iterator(); iterator.hasNext();) {
+                                String cleGroupe = iterator.next();
+                                String[] strParams = {cleGroupe};
+                                listeGroupeChampsEtendus.addItem(Msg.get("import-champs-projets", strParams), cleGroupe);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java
 New file
 ,0 → 1,1005
+package org.tela_botanica.client.vues.observation;
+import java.util.HashMap;
+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.i18n.Msg;
+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.Event;
+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.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 = "IDLOCLOCALITE, 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(Msg.get("observations"));
+                bt.setTaillePageParDefaut(20);
+                bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ;
+                Toolbar barreActions = new Toolbar();
+                ToolbarButton publier = new ToolbarButton(Msg.Get("rendre-publiques"));
+                publier.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button b, EventObject e) {
+                                observationMediateur.transmettreObservations(true);
+                        }
+                });
+                ToolbarButton privatiser = new ToolbarButton(Msg.Get("rendre-privees"));
+                privatiser.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button b, EventObject e) {
+                                observationMediateur.transmettreObservations(false);
+                        }
+                });
+                ToolbarButton supprimer = new ToolbarButton(Msg.get("supprimer"));
+                supprimer.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button b, EventObject e) {
+                                observationMediateur.supprimerObservations();
+                        }
+                });
+                ToolbarButton importer = new ToolbarButton(Msg.get("importer"));
+                importer.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button b, EventObject e) {
+                                observationMediateur.afficherFormulaireImportObservation();
+                        }
+                });
+                ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> " + Msg.get("exporter") + " </a>");
+                ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"" + Msg.get("export-nc-ce-bf-bv") + "\"> " + Msg.get("export-etendu") + " </a>");
+                ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"" + Msg.get("etiquettes-pdf") + "\"> " + Msg.get("etiquettes") + " </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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("referentiel"), "referentiel_taxo_observation", 15, true, colRend);
+                nomSaisiObservation = new ColumnConfig(Msg.get("nom-saisi"), "nomSaisi_observation", 130, true, colRend);
+                nomRetenuObservation = new ColumnConfig(Msg.get("nom-retenu"), "nomRetenu_observation", 130, true, colRend);
+                familleObservation = new ColumnConfig(Msg.get("famille"), "famille_observation", 50, true, colRend);
+                lieuObservation = new ColumnConfig(Msg.get("lieu"), "lieu_observation", 130, true, colRend);
+                altitudeObservation = new ColumnConfig(Msg.Get("altitude-court"), "altitude_observation", 10, true, colRend);
+                dateObservation = new ColumnConfig(Msg.get("date"), "date_observation", 70, true, dateRend);
+                abondanceObservation = new ColumnConfig(Msg.get("abondance"), "abondance", 50, true, colRend);
+                certitudeObservation = new ColumnConfig(Msg.get("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(Msg.get("phenologie"), "phenologie", 40, true, colRend);
+                ordreObservation = new ColumnConfig(Msg.get("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;
+                                Timer t = new Timer() {
+                                        @Override
+                                        public void run() {
+                                                enregistrerEtatTri();
+                                                observationMediateur.obtenirListeObservation();
+                                        }
+                                };
+                                // Le changement de tri n'est pas immédiat et si on recharge le liste tout de suite
+                                // on a l'ancien tri et pas le nouveau (200 millisecondes suffisent et ne se voient pas)
+                                // #mondeDeMerde
+                                t.schedule(200);
+                        }
+                });
+                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(Msg.get("glissez-observations-pour-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(Msg.get("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\"> "+Msg.get("filtres")+" - "+texteFiltresEnCours+"</span>";
+                }
+                this.setTitle(Msg.get("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 = Msg.get("departement");
+                } else if(nomFiltre.equals("localite")) {
+                        nomFiltre = Msg.get("localite");
+                } else if(nomFiltre.equals("nom_taxon")) {
+                        nomFiltre = Msg.get("recherche");
+                } else if(nomFiltre.equals("id_mots_cles")) {
+                        nomFiltre = Msg.get("projets");
+                } else if(nomFiltre.equals("lieudit")) {
+                        nomFiltre = Msg.get("lieu-dit");
+                } else {
+                        nomFiltre = Msg.get(nomFiltre);
+                }
+                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", Msg.get("inconnue"));
+                valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", Msg.get("inconnue"));
+                valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", Msg.get("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;
+        }
+        public String renvoyerTri() {
+                String tri = "ordre";
+                if(triActif) {
+                        HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri();
+                        if(corr.containsKey(champTri)) {
+                                tri = corr.get(champTri);
+                        }
+                }
+                return tri;
+        }
+        public String renvoyerDirectionTri() {
+                try {
+                        return (triActif) ? directionTri.getDirection() : "ASC";
+                } catch (Exception e) {
+                        return "ASC";
+                }
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property
 Added: svn:mergeinfo

 /trunk/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java
 New file
 ,0 → 1,197
+package org.tela_botanica.client.vues.observation;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.Get("mots-cles") + " :");
+                champRecherche = new TextField();
+                ok = new Button(Msg.get("rechercher"));
+                afficherNuage = new Button(Msg.get("voir-mots-cles"));
+                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

 /trunk/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java
 New file
 ,0 → 1,2383
+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.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;
+import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
+import org.tela_botanica.client.modeles.dao.ListeReferentielLocaliteAsynchroneDAO;
+import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;
+import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;
+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.Observation;
+import org.tela_botanica.client.modeles.objets.Ontologies;
+import org.tela_botanica.client.modeles.objets.ReferentielLocalite;
+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.ChampSaisieEtendu;
+import org.tela_botanica.client.util.FormulaireSaisieChampEtendu;
+import org.tela_botanica.client.util.Util;
+import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox;
+import com.google.gwt.core.client.Callback;
+import com.google.gwt.event.dom.client.ClickEvent;
+import com.google.gwt.event.dom.client.ClickHandler;
+import com.google.gwt.http.client.Response;
+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.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.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 AutoCompletionComboBox lieudit = null;
+        private AutoCompletionComboBox station = null;
+        private AutoCompletionComboBox milieu = null;
+        private TextField comment = null;
+        private AutoCompletionComboBox  localite = null;
+        private String codeLocalite = null;
+        private String pays = null;
+        private AutoCompletionComboBox  espece = null;
+        private Map<String, ReferentielNom> referentielNom = null;
+        private Map<String, ReferentielLocalite> referentielLocalite = null;
+        private String numeroNom = null;
+        private String numeroOrdre = null;
+        private String referentielTaxo = null;
+        private String referentielGeo = null;
+        private Map<String, String> avertissementPresence = new HashMap<String, String>();
+        private boolean enRequeteChrologie = false;
+        // Pour remise a zero partielle lors d'une validation
+        private enum Champs {
+            DATE, LIEUDIT, STATION, MILIEU, COMMENT, LOCALITE, ESPECE, TOUT, LATITUDE, LONGITUDE, ALTITUDE, ABONDANCE, CERTITUDE, REFERENTIELTAXO, PHENOLOGIE;
+            @Override
+                public String toString() {
+                switch(this) {
+                case DATE:
+                        return "date";
+                case LOCALITE:
+                        return "localite";
+                case LIEUDIT:
+                        return "lieu dit";
+                case STATION:
+                        return "station";
+                case MILIEU:
+                        return "milieu";
+                case COMMENT:
+                        return "notes";
+                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, localite, lieu dit, station, milieu, espèce, notes, latitude, longitude, altitude, abondance, identification, referentiel, phenologie";
+                }
+                        return TOUT.toString();
+            }
+        };
+        private String formatDate = null ;
+        private Button boutonOK = new Button(Msg.get("creer"));
+        private Button boutonModifier = new Button(Msg.get("modifier"));
+        private Button boutonSupprimer = new Button(Msg.get("supprimer"));
+        private Button boutonReinitialiser = new Button(Msg.get("reinitialiser"));
+        private boolean selectionlocalite=false;
+        private boolean selectionEspece=false;
+        private boolean selectionAbondance = false;
+        private boolean selectionCertitude = false;
+        private boolean selectionPhenologie = false;
+        private final String VALEURS_MULTIPLES = "("+Msg.get("valeurs-multiples")+")";
+        private final String modeleMessageModif = "localite:lieu-dit:station:milieu:latitude:longitude:altitude:date:espece:notes:abondance:identification:referentiel:phenologie";
+        private boolean localiteModifiee = 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 htmllocalitePanel = null;
+        private MultiFieldPanel coordPanel;
+        private TextField coordonnees;
+        private Label lienSelectionlocalite = null;
+        private HTML afficherFormulaireLatLon;
+        private HTML basculerverscarto;
+        private boolean longlatAjoutee;
+        private boolean latModifiee;
+        private boolean longModifiee;
+        private boolean altModifiee;
+        protected boolean recherchelocaliteEnCours = false;
+        private Timer tCoord;
+        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(Msg.get("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
+                localite = new AutoCompletionComboBox(Msg.get("localite"), ListeReferentielLocaliteAsynchroneDAO.getUrlReferentielLocalites()) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(Response response) {
+                                referentielLocalite = Util.parserRetourReferentielLocaliteIndexeParNom(response);
+                                return Util.convertirListeReferentielLocaliteVersMap(referentielLocalite);
+                        }
+                        @Override
+                        public void onSelectionValeur() {
+                                localiteModifiee = true;
+                                surSelectionLocalite();
+                                verifierPresenceTaxonSaisi();
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                localiteModifiee = true;
+                                verifierPresenceTaxonSaisi();
+                        }
+                        @Override
+                        public void onValidationSaisie() {
+                                validerSaisie(Champs.LOCALITE);
+                        }
+                };
+                //création du lien "Accès carto" dans le formulaire;
+                basculerverscarto = new HTML(" <a id=\"lien_carto\" title=\""+Msg.get("aide-lien-localiser")+"\" href=\"#\" tabindex=\"2\">"+Msg.get("localiser-zone")+"</a>");
+                basculerverscarto.addStyleName("lien_actif");
+                //création info bulle sur le lien "accès carto"
+                ToolTip tip2 = new ToolTip();
+                tip2.setHtml(Msg.get("aide-lien-localiser"));
+                tip2.applyTo(basculerverscarto.getElement());
+                //Sur une meme ligne, ajout de plusieurs champs
+                htmllocalitePanel = new MultiFieldPanel();
+                int largeurlocalite = Window.getClientWidth()/4;
+                htmllocalitePanel.addToRow(localite, largeurlocalite);
+                htmllocalitePanel.addToRow(basculerverscarto, 160);
+                htmllocalitePanel.setBorder(false);
+                htmllocalitePanel.setId("x-localite-panel");
+                panneauPremierColonne.add(htmllocalitePanel);
+            station = new AutoCompletionComboBox(Msg.get("station"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_STATION)) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(Response response) {
+                                return Util.parserRetourReferentielPerso(response);
+                        }
+                        @Override
+                        public void onSelectionValeur() {
+                                stationModifiee = true;
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                stationModifiee = true;
+                        }
+                        @Override
+                        public void onValidationSaisie() {
+                                validerSaisie(Champs.STATION);
+                        }
+                        @Override
+                        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                                return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur);
+                        }
+                };
+            panneauPremierColonne.add(station, new AnchorLayoutData("95%"));
+                latitude = new TextField(Msg.get("lat"), "lat");
+                latitude.setGrowMax(70);
+                latitude.setAllowBlank(true);
+            longitude = new TextField(Msg.get("lon"), "lon");
+            longitude.setGrowMax(70);
+                longitude.setAllowBlank(true);
+                altitude = new TextField(Msg.get("alt"), "alt");
+                altitude.setGrowMax(70);
+                altitude.setAllowBlank(true);
+                lienSelectionlocalite = new Label("");
+                lienSelectionlocalite.setId("conteneur_selection_localite");
+                lienSelectionlocalite.setStyleName("conteneur_selection_localite");
+                lienSelectionlocalite.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(lienSelectionlocalite, new ColumnLayoutData(largeur));
+                lienSelectionlocalite.addClass("lien_decale");
+                coordPanel.setBorder(false);
+                coordPanel.addToRow(altitude, new ColumnLayoutData(largeur));
+                  //création du champs coordonnées
+                referentielGeo = Configuration.getReferentielGeo();
+                coordonnees = new TextField(Msg.get("coordonnees"), "", 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=\""+Msg.get("indication-formulaire-lat-lon")+"\" class=\"lien_actif\" id=\"lien_coord\" href=\"#\" tabindex=\"6\">"+Msg.get("saisie-lat-lon")+" ("+referentielGeo+")</a>" +
+                                "<span><span style=\"padding-left:20px\" class=\"conteneur_lien_localiser_lat_lon\">"+
+                                "<a title=\""+Msg.get("indication-formulaire-localiser")+"\" class=\"lien_actif\" id=\"lien_carto_coord\" href=\"#\" tabindex=\"7\">"+Msg.get("localiser-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(Msg.get("date"), "date", 250);
+            date.setAllowBlank(true);
+            formatDate = "d/m/Y";
+            date.setFormat(formatDate);
+            date.setTitle(Msg.get("indication-format-date"));
+            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(Msg.get("referentiel"));
+            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 AutoCompletionComboBox(Msg.get("espece"), ListeReferentielNomAsynchroneDAO.getBaseUrlReferentielNom()) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(Response response) {
+                                // TODO: bien penser à l'unicité des clés, ici on suppose que
+                                // genre espèce auteur suffit mais quelquefois on peut avoir des doublons
+                                referentielNom = Util.parserRetourReferentielNomIndexeParNom(response);
+                                return Util.convertirListeReferentielNomVersMap(referentielNom);
+                        }
+                        @Override
+                        public void onSelectionValeur() {
+                                especeModifiee = true;
+                                surSelectionEspece();
+                                verifierPresenceTaxonSaisi();
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                especeModifiee = true;
+                                // Pour éviter qu'un mauvais nn ne soit gardé lors d'une modification
+                                // vers un nom ne faisant pas partie du référentiel
+                                numeroNom = null;
+                                if(referentielNom.containsKey(espece.getText())) {
+                                        numeroNom = referentielNom.get(espece.getText()).getNumeroNom();
+                                }
+                                verifierPresenceTaxonSaisi();
+                        }
+                        @Override
+                        public void onValidationSaisie() {
+                                validerSaisie(Champs.ESPECE);
+                        }
+                        @Override
+                        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                                return ListeReferentielNomAsynchroneDAO.formaterUrlAutoCompletionReferentielNom(urlRequete, referentielTaxo, valeur);
+                        }
+                        @Override
+                        protected String preTraiterValeurAvantAffichage(String valeur) {
+                                ReferentielNom nomValeur = referentielNom.get(valeur);
+                                String valeurAffichee = nomValeur.getNom();
+                                // Pour afficher les noms retenus en gras
+                                if (nomValeur.estRetenu()) {
+                                        valeurAffichee = "<span class=\"nomRetenu\">"+nomValeur.getNom().trim()+"</span>";
+                                }
+                                return valeurAffichee;
+                        }
+            };
+            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(Msg.get("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 AutoCompletionComboBox(Msg.get("lieu-dit"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_LIEU_DIT)) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(Response response) {
+                                return Util.parserRetourReferentielPerso(response);
+                        }
+                        @Override
+                        public void onSelectionValeur() {
+                                lieuDitModifie = true;
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                lieuDitModifie = true;
+                        }
+                        @Override
+                        public void onValidationSaisie() {
+                                validerSaisie(Champs.LIEUDIT);
+                        }
+                        @Override
+                        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                                return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur);
+                        }
+                };
+            panneauSecondeColonne.add(lieudit,  new AnchorLayoutData("95%"));
+            milieu = new AutoCompletionComboBox(Msg.get("milieu"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_MILIEU)) {
+                        @Override
+                        protected Map<String, String> parserResultatRequete(Response response) {
+                                return Util.parserRetourReferentielPerso(response);
+                        }
+                        @Override
+                        public void onSelectionValeur() {
+                                milieuModifie = true;
+                        }
+                        @Override
+                        protected void onModificationValeur() {
+                                milieuModifie = true;
+                        }
+                        @Override
+                        public void onValidationSaisie() {
+                                validerSaisie(Champs.MILIEU);
+                        }
+                        @Override
+                        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
+                                return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur);
+                        }
+            };
+            panneauSecondeColonne.add(milieu,  new AnchorLayoutData("95%"));
+            comment = new TextArea(Msg.get("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(Msg.get("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(Msg.get("phenologie"));
+            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(boutonReinitialiser);
+                }
+                else {
+                        panneauFormulaire.addButton(boutonOK);
+                        panneauFormulaire.addButton(boutonModifier);
+                        panneauFormulaire.addButton(boutonSupprimer);
+                        panneauFormulaire.addButton(boutonReinitialiser);
+                }
+                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();
+                        htmllocalitePanel.doLayout();
+                        htmlPanel.doLayout();
+                                redimensionnerChampsEtendus();
+                        doLayout();
+                }
+            });
+                lienAfficherChampsEtendus = new HTML(Msg.get("afficher-champs-etendus"));
+                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(Msg.get("afficher-champs-etendus"));
+                                } else {
+                                        afficherChampsEtendus = true;
+                                        if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) {
+                                                conteneurChampEtenduGauche.show();
+                                                conteneurChampEtenduDroite.show();
+                                                redimensionnerChampsEtendus();
+                                        }
+                                        lienAfficherChampsEtendus.setText(Msg.get("cacher-champs-etendus"));
+                                }
+                        }
+                });
+                if(Configuration.saisieChampsEtendusActivee()) {
+                        // Chargement du cache des correspondances cles/labels du catalogue
+                        ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
+                        lrceDao.obtenirGroupesChampsEtendus(this);
+                        lrceDao.obtenirCatalogueChampsEtendus(this);
+                        lienAjouterChampsEtendus = new HTML(Msg.get("ajouter-champ-etendu"));
+                        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();
+        }
+        protected void surSelectionEspece() {
+                ReferentielNom nom = referentielNom.get(espece.getText());
+                numeroNom = nom.getNumeroNom();
+                selectionEspece = true;
+                observationMediateur.obtenirImageInformationExternes(referentielTaxo, numeroNom);
+        }
+        protected void surSelectionLocalite() {
+                ReferentielLocalite infosLoc = referentielLocalite.get(localite.getText());
+        codeLocalite = infosLoc.getCodeLocalite();
+        selectionlocalite=true;
+        }
+        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();
+                                formChamp.redimensionner(popUpAjoutChampEtendu.getOffsetWidth() - 13);
+                        }
+                });
+        }
+        private void ajouterChampEtenduAuFormulaire(ChampSaisieEtendu nChamp, boolean fermerPopup) {
+                ChampEtendu chet = new ChampEtendu(nChamp.getCle(), nChamp.getLabel(), "");
+                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 {
+                        String[] stParams = {chet.getLabel()};
+                        Window.alert(Msg.get("indication-champ-etendu-existe-deja", stParams));
+                }
+        }
+        private void ajouterToolTipsBoutons() {
+                boutonOK.setTitle(Msg.get("indication-bouton-creer-obs"));
+                boutonModifier.setTitle(Msg.get("indication-bouton-modifier-obs"));
+                boutonSupprimer.setTitle(Msg.get("indication-bouton-supprimer-obs"));
+                boutonReinitialiser.setTitle(Msg.get("indication-bouton-reinitialiser-obs"));
+        }
+        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(localite.getText() != null && !localite.getText().equals("")) {
+                                        obtenirInformationLocalite();
+                                        longlatAjoutee = true;
+                                } else {
+                                        Window.alert(Msg.get("indication-localite-vide-invalide"));
+                                }
+                        }
+                });
+                if(!Ext.isIE() && Window.getClientWidth() < 1200) {
+                        int largeurN = (int)largeur;
+                        latitude.setWidth(largeurN+"px");
+                        longitude.setWidth(largeurN+"px");
+                        lienSelectionlocalite.setWidth(largeurN+"px");
+                }
+        }
+        private void ajouterListeners()
+        {
+                // Listener completion communne
+                final Rafraichissable r = this;
+                ListenerConfig listenerConfiglocalite=new ListenerConfig();
+                listenerConfiglocalite.setDelay(200);
+                listenerConfiglocalite.setStopPropagation(false);
+                listenerConfiglocalite.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(!recherchelocaliteEnCours && coord != null && (longModifiee || latModifiee)) {
+                                recherchelocaliteEnCours = true;
+                                Ext.get(lienSelectionlocalite.getElement()).mask(Msg.get("recherche"));
+                                observationMediateur.obtenirInformationCoord(r,coord[0], coord[1]);
+                        }
+                        }
+                };
+            ajouterListenerChampEvenementsClavier(date);
+                ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo);
+                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();
+                                } else {
+                                        modifierObservation() ;
+                                }
+                        }
+                });
+                boutonSupprimer.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                if(!selectionMultiple) {
+                                        supprimerObservation();
+                                } else {
+                                        observationMediateur.supprimerObservations();
+                                }
+                        }
+                });
+                boutonReinitialiser.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                        setSelectionMultiple(false);
+                                        raz();
+                        }
+                });
+                this.addListener(new ContainerListenerAdapter() {
+                        @Override
+                        public void onAfterLayout(Container self) {
+                                localite.focus();
+                        }
+                });
+        }
+        private void ajouterListenerChampsCombobox() {
+                selecteurReferentielTaxo.addListener(new ComboBoxListenerAdapter() {
+             @Override
+                        public void onSelect(ComboBox comboBox, Record record, int index) {
+                 referentielTaxo = record.getAsString("valeur");
+                 observationMediateur.setRefTaxSelectionne(index);
+                 referentielTaxoModifie = true;
+             }
+         });
+                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(localite)) {
+                        if(champ.equals(localite)) {
+                                if (selectionlocalite) {
+                                 localiteModifiee= true;
+                                 selectionlocalite=false;
+                         }
+                        else {
+                                validerSaisie(Champs.LOCALITE);
+                         }
+                        }
+                }
+        }
+        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="";
+                especeModifiee = true;
+                }
+                if(champ.equals(selecteurReferentielTaxo)) {
+                        referentielTaxoModifie = true;
+                }
+                if(champ.equals(date)) {
+                        dateModifiee = true;
+                }
+                if(champ.equals(localite)) {
+                        codeLocalite="";
+                localite.collapse();
+                localiteModifiee= true;
+                }
+        }
+        /**
+         * Validation de la saisie
+         */
+        private void validerSaisie(Champs champs) {
+                if(!selectionMultiple) {
+                        ajouterObservation();
+                        raz(champs);
+                } else {
+                        modifierObservationEnMasse();
+                }
+        }
+        /**
+         * 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) {
+                // 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(recherchelocaliteEnCours) {
+                                afficherIndicationlocalite(infosComm);
+                        } else {
+                                rafraichirlocaliteEtCoord(infosComm);
+                        }
+                }
+        }
+        private void afficherIndicationlocalite(
+                        final EntiteGeographiqueObservation infosCom) {
+                String nlocalite = "";
+                if(infosCom != null && infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().trim().isEmpty()) {
+                        nlocalite += infosCom.getZoneGeo();
+                        if(infosCom.getIdZoneGeo() != null && !infosCom.getIdZoneGeo().trim().isEmpty()) {
+                                if(Util.estUnDepartement(infosCom.getIdZoneGeo())) {
+                                        nlocalite += " ("+Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo())+")";
+                                } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) {
+                                        nlocalite += " ("+infosCom.getPays()+")";
+                                }
+                        } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) {
+                                nlocalite += " ("+infosCom.getPays()+")";
+                        }
+                        lienSelectionlocalite.setHtml("<a id=\"lien_selection_localite\" tabindex=\"9\">"+nlocalite+"</a>");
+                        lienSelectionlocalite.setStyleName("img-curseur-depl");
+                        Ext.get("lien_selection_localite").addListener("click",new EventCallback() {
+                                @Override
+                                public void execute(EventObject e) {
+                                        rafraichirlocalite(infosCom);
+                                }
+                        });
+                        Ext.get("lien_selection_localite").addListener("keypress",new EventCallback() {
+                                @Override
+                                public void execute(EventObject e) {
+                                        if(e.getCharCode() == KEY_ENTER) {
+                                                rafraichirlocalite(infosCom);
+                                        }
+                                }
+                        });
+                        Ext.get("lien_selection_localite").addListener("focus",new EventCallback() {
+                                @Override
+                                public void execute(EventObject e) {
+                                        Ext.get("lien_selection_localite").toggleClass("lien_sel");
+                                }
+                        });
+                        Ext.get("lien_selection_localite").addListener("blur",new EventCallback() {
+                                @Override
+                                public void execute(EventObject e) {
+                                        Ext.get("lien_selection_localite").toggleClass("lien_sel");
+                                }
+                        });
+                } else {
+                        if(recherchelocaliteEnCours) {
+                                lienSelectionlocalite.setHtml("<span id=\"aucune_selection_localite\"> "+Msg.get("erreur-localisation")+" </span>");
+                        } else {
+                                lienSelectionlocalite.setHtml("<span id=\"aucune_selection_localite\"> </span>");
+                        }
+                }
+                Ext.get(lienSelectionlocalite.getElement()).unmask();
+                recherchelocaliteEnCours = false;
+        }
+        private void rafraichirlocalite(EntiteGeographiqueObservation infosCom) {
+                String nlocalite = "";
+                if(infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().equals("")) {
+                        nlocalite += infosCom.getZoneGeo();
+                }
+                if(infosCom.getIdZoneGeo() != null && Util.estUnDepartement(infosCom.getIdZoneGeo())) {
+                        String codeGeoFormate = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo());
+                        nlocalite += " ("+codeGeoFormate+")";
+                        codeLocalite = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo());
+                } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) {
+                        nlocalite += " ("+infosCom.getPays()+")";
+                }
+                if (!nlocalite.isEmpty()) {
+                        // Vide ou null, on remplace !
+                        if(localite.getText() == null || localite.getText().trim().isEmpty()) {
+                                localite.setValue(nlocalite);
+                        } else {
+                                // Afin de pas effacer un pays précédemment saisi, si on a déjà saisi une localité
+                                // avec le même nom mais avec un pays, on ne remplace rien
+                                if(localite.getText() != null && !localite.getText().contains(nlocalite)) {
+                                        localite.setValue(nlocalite);
+                                }
+                        }
+                        localiteModifiee = true;
+                }
+        }
+        // Se déclenche au retour de la "localisation sur la carte"
+        private void rafraichirlocaliteEtCoord(EntiteGeographiqueObservation infosCom) {
+                rafraichirlocalite(infosCom);
+                if(infosCom.getLat() != null && !infosCom.getLat().equals("")) {
+                        latitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLat(), 5));
+                }
+                if(infosCom.getLon() != null && !infosCom.getLon().equals("")) {
+                        longitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLon(), 5));
+                }
+                latModifiee = true;
+                longModifiee = true;
+                coordPanel.setVisible(true);
+        }
+        public void ajouterObservation() {
+                if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) {
+                        Window.alert(Msg.get("indication-date-invalide"));
+                        date.setInvalidText(Msg.get("date-invalide"));
+                        return;
+                }
+                affecterCodeLocaliteOuPays();
+                String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue());
+                Observation obs=new Observation(espece.getText(),numeroNom,localite.getText(),codeLocalite,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs);
+                String[] coords = getValeurCoordonnees();
+                obs.setPays(pays);
+                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(Msg.get("question-modifier-observation")+" ?")) {
+                        return;
+                }
+                if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) {
+                        Window.alert(Msg.get("indication-date-invalide"));
+                        date.setInvalidText(Msg.get("date-invalide"));
+                        return;
+                }
+                affecterCodeLocaliteOuPays();
+                String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue());
+                Observation obs=new Observation(espece.getText(),numeroNom,localite.getText(),codeLocalite,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs);
+                obs.setNumeroOrdre(numeroOrdre);
+                String[] coords = getValeurCoordonnees();
+                obs.setPays(pays);
+                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 affecterCodeLocaliteOuPays() {
+                codeLocalite = "";
+                pays = "";
+                // Soit un numéro de département, soit un code de pays à deux lettres
+                String[] codeCom = localite.getText().split(" ");
+                if(codeCom.length > 1 && ressembleAUnCodePaysOuDepartement(codeCom[codeCom.length - 1])) {
+                        String codeLoc = codeCom[codeCom.length - 1].replace('(', ' ');
+                        codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim();
+                        if(Util.estUnDepartement(codeLoc)) {
+                                codeLocalite = codeLoc ;
+                        } else {
+                                pays = codeLoc.toUpperCase();
+                        }
+                }
+        }
+        private boolean ressembleAUnCodePaysOuDepartement(String s) {
+                String sP = s.replace("(", "").replace(")", "").trim();
+                boolean contientDesParentheses = s.contains("(") && s.contains(")");
+                boolean estUnCodePays = !Util.estUnNombre(sP) && (sP.length() == 2);
+                boolean estUnCodeDepartement = Util.estUnNombre(sP) && (sP.length() >= 1 && sP.length() <= 5);
+                return contientDesParentheses && (estUnCodePays || estUnCodeDepartement);
+        }
+        private void modifierObservationEnMasse() {
+                //TODO: factoriser
+                String paysM = null;
+                String localiteM = null;
+                String codeLocaliteM = 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(localiteModifiee && ! localite.getRawValue().equals(VALEURS_MULTIPLES)) {
+                        localiteM = localite.getText();
+                        // Soit un numéro de département, soit un code de pays à deux lettres
+                        String[] codeCom = localite.getText().split(" ");
+                        if(codeCom.length > 1) {
+                                String codeLoc = codeCom[1].replace('(', ' ');
+                                codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim();
+                                if(Util.estUnDepartement(codeLoc)) {
+                                        codeLocaliteM = codeLoc ;
+                                } else {
+                                        paysM = codeLoc;
+                                }
+                        }
+                }
+                else {
+                        champs = champs.replaceAll("localite", "");
+                }
+                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(":notes", "");
+                }
+                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", "");
+                }
+                // TODO : trouver un meilleur système que ça pour gérer le message
+                // affiché
+                String[] champsSt = champs.split(":");
+                String champsTraduits = "";
+                for (int i = 0; i < champsSt.length; i++) {
+                        // TODO: vérifier pourquoi des fois la chaîne est vide
+                        // ou faire mieux, trouver un meilleur système comme écrit au dessus !
+                        if(!champsSt[i].trim().isEmpty()) {
+                                champsTraduits += Msg.get(champsSt[i]);
+                                champsTraduits += (i != champsSt.length - 1) ? ", " : "";
+                        }
+                }
+                String[] stParams = {champsTraduits};
+                String message = Msg.get("question-modifier-champs-observation", stParams)+" ?" ;
+                if(champs.trim().equals("")) {
+                        Window.alert(Msg.get("indication-aucun-champ-modifie"));
+                } else {
+                        Observation obs = new Observation(especeM,numNomSelM,localiteM,codeLocaliteM,lieuDitM,stationM,milieuM, commM,dateM);
+                        obs.setPays(paysM);
+                        obs.setNumeroOrdre(numeroOrdre);
+                        obs.setLatitude(latM);
+                        obs.setLongitude(longM);
+                        obs.setAltitude(altM);
+                        obs.setAbondance(abondanceM);
+                        obs.setCertitude(certitudeM);
+                        // Afin de transmettre un ensemble cohérent on force aussi
+                        // l'envoi du référentiel en cas de maj de l'espèce
+                        if(especeModifiee) {
+                                referentielTaxoM = getReferentielTaxo();
+                        }
+                        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.getIdentifiantLocalite().isEmpty() && !obs.getPays().isEmpty()) {
+                        idLoc = obs.getPays();
+                }
+                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)) {
+                                        localite.setValue(obs.getLocalite()+" ("+idLoc+")") ;
+                                } else {
+                                        localite.setValue(VALEURS_MULTIPLES);
+                                }
+                        }
+                        else
+                        {
+                                localite.setValue(obs.getLocalite());
+                        }
+                }
+                if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) {
+                        codeLocalite = 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();) {
+                                ChampSaisieEtendu 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) {
+                champsEtendus = Util.trierListeChampsEtendus(champsEtendus);
+                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());
+                        HashMap<String, String> correspondancesClesLabel = ListeReferentielChampsEtendusDAO.cacheClesLabels;
+                        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 = id;
+                                // Si le champ possède un clé déjà définie par le catalogue, elle lui sera affectée
+                                // sinon on la formate en la "déchamotant" et en ajoutant des espaces
+                                if(correspondancesClesLabel.containsKey(id)) {
+                                        label = correspondancesClesLabel.get(id);
+                                } else {
+                                        label = Util.formaterCleChampsEtenduPourAffichage(label);
+                                }
+                                ChampSaisieEtendu champTexteEtendu = new ChampSaisieEtendu(label, id, ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(id));
+                                if(champ.equals(champsAFocus)) {
+                                        champTexteEtendu.focus();
+                                }
+                                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 {
+                                redimensionnerChampsEtendus();
+                        }
+                } else {
+                        lienAfficherChampsEtendus.setVisible(false);
+                }
+                doLayout();
+        }
+        private void redimensionnerChampsEtendus() {
+                int largeur = conteneurChampEtenduGauche.getWidth();
+                if(largeur <= 0) {
+                        Timer t = new Timer() {
+                                @Override
+                                public void run() {
+                                        redimensionnerChampsEtendus();
+                                }
+                        };
+                        t.schedule(150);
+                } else {
+                        for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator
+                                        .hasNext();) {
+                                ChampSaisieEtendu ch = listeChampsEtendus.get(iterator.next());
+                                ch.redimensionner(largeur - 15);
+                                if(ch.getFieldWidth() < ch.getLabelWidth()) {
+                                        ch.addClass("panneauModePetiteLargeur");
+                                        ch.agrandirChamp(largeur - 82);
+                                } else {
+                                        //ch.removeClass("panneauModePetiteLargeur");
+                                }
+                        }
+                }
+        }
+        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();
+                                ChampSaisieEtendu champTexteEtendu = listeChampsEtendus.get(cle);
+                                String label = champTexteEtendu.getLabel();
+                                String valeur = champTexteEtendu.getRawValue();
+                                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 LOCALITE:
+                                localite.reset() ;
+                                codeLocalite ="";
+                                pays="";
+                                latitude.reset();
+                                longitude.reset();
+                                break;
+                        case ESPECE:
+                                espece.reset();
+                                numeroNom = "" ;
+                                numeroOrdre = "";
+                                break;
+                        case LATITUDE:
+                                latitude.reset();
+                                afficherIndicationlocalite(null);
+                                break;
+                        case LONGITUDE:
+                                longitude.reset();
+                                afficherIndicationlocalite(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:
+                                localite.reset();
+                                date.reset() ;
+                                lieudit.reset() ;
+                                station.reset() ;
+                                milieu.reset() ;
+                                comment.reset() ;
+                                milieu.reset() ;
+                                latitude.reset();
+                                longitude.reset();
+                                altitude.reset();
+                                pays="";
+                                codeLocalite ="";
+                                espece.reset();
+                                selecteurAbondance.clearValue();
+                                selecteurCertitude.clearValue();
+                                selecteurReferentielTaxo.clearValue();
+                                selecteurStadePheno.clearValue();
+                                referentielTaxo = "";
+                                numeroNom = "" ;
+                                numeroOrdre = "";
+                                afficherIndicationlocalite(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) {
+                        boutonReinitialiser.enable();
+                        boutonOK.enable();
+                } else {
+                        boutonReinitialiser.disable();
+                        boutonOK.disable();
+                }
+        }
+        public boolean getSelectionMultiple() {
+                return selectionMultiple;
+        }
+        private void calculerAfficherDifferences(ListeObservation listeObs) {
+                String codeLocalite = null;
+                String pays = null;
+                String localite = 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());
+                        pays = comparerDifferencesChamps(pays, obsEnCours.getPays());
+                        codeLocalite = comparerDifferencesChamps(codeLocalite, obsEnCours.getIdentifiantLocalite());
+                        localite = comparerDifferencesChamps(localite, 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,localite,codeLocalite,lieuDit,station,milieu, notes,date);
+                obs.setPays(pays);
+                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 = "";
+                        if(valeurActuelle == null) {
+                                retour = nouvelleValeur;
+                        } else {
+                                if(valeurActuelle.equals(nouvelleValeur)) {
+                                        retour = valeurActuelle;
+                                } else {
+                                        retour = VALEURS_MULTIPLES;
+                                }
+                        }
+                return retour;
+        }
+        private void reinitialiserValeurModifiees() {
+                localiteModifiee = 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()
+        {
+                localite.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);
+                boutonReinitialiser.setTabIndex(18);
+        }
+        private void obtenirInformationCoord() {
+                if(coordonneesValides() != null) {
+                        observationMediateur.obtenirInformationCoord(coordonneesValides()[0],coordonneesValides()[1]);
+                } else {
+                        // Centrage de la carte sur une zone correspondant plus ou moins au référentiel.
+                        // En dur car la config est tellement mal foutue que j'ai envie de me pendre.
+                        String referentiel = this.getReferentielTaxo();
+                        String referentielRacine = referentiel.substring(0, referentiel.indexOf(':'));
+                        Double lat = null, lon = null;
+                        int zoom = 6;
+                        switch(referentielRacine) {
+                                case "bdtre" :
+                                        lat = -21.10;
+                                        lon = 55.30;
+                                        zoom = 7;
+                                break;
+                                case "isfan" :
+                                        lat = 29.28358;
+                                        lon = 10.21884;
+                                        zoom = 5;
+                                        break;
+                                case "apd" :
+                                        lat = 8.75624;
+                                        lon = 1.80176;
+                                        zoom = 5;
+                                        break;
+                                case "bdtxa" :
+                                        lat = 14.6;
+                                        lon = -61.08334;
+                                        zoom = 7;
+                                        break;
+                                case "lbf" :
+                                        lat = 33.53;
+                                        lon = 35.30;
+                                        zoom = 7;
+                                        break;
+                                case "florical" :
+                                        lat = -21.40722;
+                                        lon = 165.4541;
+                                        zoom = 7;
+                                        break;
+                                case "aublet" :
+                                        lat = 3.80287;
+                                        lon = -53.09692;
+                                        zoom = 7;
+                                        break;
+                                case "bdtfx" :
+                                default:
+                                        lat = 47.0504;
+                                        lon = 2.2347;
+                                        zoom = 6;
+                        }
+                        if (lat != null && lon != null) {
+                                // centrage sur la zone
+                                EntiteGeographiqueObservation infos = new EntiteGeographiqueObservation();
+                                infos.setLon("" + lon);
+                                infos.setLat("" + lat);
+                                infos.setZoom(zoom);
+                                observationMediateur.rafraichirFenetreCartoSurPoint(infos);
+                        } else {
+                                // affichage par défaut au cas où on n'aurait pas trouvé de coordonnées pour centrer
+                                observationMediateur.afficherFenetreCarto();
+                        }
+                }
+        }
+        private void obtenirInformationLocalite() {
+                String idLoc = obtenirIdLocalite();
+                observationMediateur.obtenirInformationLocalite(getlocaliteSansIdLoc(), idLoc);
+        }
+        private String obtenirIdLocalite() {
+                String idLoc = "";
+                // Soit un numéro de département, soit un code de pays à deux lettres
+                String[] codeCom = localite.getText().split(" ");
+                if(codeCom.length > 1 && ressembleAUnCodePaysOuDepartement(codeCom[codeCom.length - 1])) {
+                        String codeLoc = codeCom[codeCom.length - 1].replace('(', ' ');
+                        codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim();
+                        if(Util.estUnNombre(codeLoc)) {
+                                idLoc = codeLoc ;
+                        } else {
+                                idLoc = codeLoc.toUpperCase();
+                        }
+                }
+                return idLoc;
+        }
+        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 = {"","" };
+                        return coord;
+                }
+        }
+        public String getlocalite() {
+                String valeurlocalite = "";
+                if(localite.getText() != null) {
+                        valeurlocalite = localite.getText();
+                }
+                return valeurlocalite;
+        }
+        public String getlocaliteSansIdLoc() {
+                return Util.supprimerChaineIdLocalite(getlocalite());
+        }
+        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 localiteInitialisee() {
+                return localiteModifiee;
+        }
+        public void redimensionnerFormulaire() {
+                afficherFormulaireLatLon.setWidth(panneauIntermediaire.getWidth()+"px");
+                panneauPremierColonne.doLayout();
+                panneauSecondeColonne.doLayout();
+                panneauIntermediaire.doLayout();
+                doLayout();
+        }
+        private void verifierPresenceTaxonSaisi() {
+                affecterCodeLocaliteOuPays();
+                if(!enRequeteChrologie && !codeLocalite.isEmpty() && numeroNom != null && !numeroNom.isEmpty()) {
+                        enRequeteChrologie = true;
+                        // Pour le moment, si on a un code localité, c'est qu'on est en France
+                        final String paysStr = pays.isEmpty() ? "FR" : pays;
+                        final String cleCache = numeroNom.trim()+paysStr.trim()+codeLocalite.trim();
+                        // Pour éviter de vérifier et d'afficher plus d'une fois l'avertissement de présence
+                        if(!avertissementPresence.containsKey(cleCache)) {
+                                // Pour l'instant c'est toujours France mais il serait bon un jour d'avoir une chorologie multi pays.
+                                // donc ça ne coute rien de le gérer déjà ici dans l'interface
+                                ImageInformationRepartitionAsynchroneDAO.taxonEstPresentDansZoneGeo(referentielTaxo, numeroNom, paysStr, codeLocalite, new Callback<String, String>() {
+                                        @Override
+                                        public void onSuccess(String result) {
+                                                // En cas d'absence d'infos sur la zone le service retourne "" (chaîne vide)
+                                                // En cas de non signalement dans la zone, il retourne 0,
+                                                // En cas de présence, il retourne 1
+                                                if(result.equals("0")) {
+                                                        // L'absence explicite est le seul cas qui nous interesse
+                                                        String[] stParams = {espece.getText(), codeLocalite, Configuration.getChorologieAvertissementCourriel()};
+                                                        String message = Msg.get("indication-premiere-presence", stParams);
+                                                        Window.alert(message);
+                                                }
+                                                avertissementPresence.put(cleCache, result);
+                                                enRequeteChrologie = false;
+                                        }
+                                        @Override
+                                        public void onFailure(String reason) {
+                                                enRequeteChrologie = false;
+                                        }
+                                });
+                        } else {
+                                enRequeteChrologie = false;
+                        }
+                }
+        }
+}
 Property changes:
 Added: svn:mergeinfo

 /trunk/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java
 New file
 ,0 → 1,180
+package org.tela_botanica.client.vues.observation;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("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(Msg.get("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("pays") || nom.equals("station") || nom.equals("lieudit") || nom.equals("departement") || nom.equals("localite")) {
+                        arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(nom);
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/EtatConnexionVue.java
 New file
 ,0 → 1,326
+/**
+ 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 java.util.Iterator;
+import java.util.List;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.modeles.objets.Configuration;
+import com.google.gwt.event.dom.client.ChangeEvent;
+import com.google.gwt.event.dom.client.ChangeHandler;
+import com.google.gwt.http.client.URL;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.ui.HTML;
+import com.google.gwt.user.client.ui.ListBox;
+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 HTML htmlEtatConnexion = new HTML();
+  private String labelEtatConnexion = null;
+  private ListBox listeLangues = null;
+  /**
+   * Ouh c'est pas beau, ça ! Mais avec Google Web Toolshit, ça
+   * marche toujours mieux que quand on fait des trucs beaux :-)
+   */
+  private String liens = "<div id=\"liensExt\">"
+                  + "<a id=\"lienRemarques\" title=\""+Msg.get("adresser-remarque-probleme")+"\""
+                  +     " href=\"" + Configuration.getRemarquesBaseUrl() + "?lang=" + Msg.getLangue() + "&service=" + Configuration.getServiceContact()
+                  +     "&pageSource=" + URL.encodeQueryString(Window.Location.getHref()) + "\""
+                  + " onClick=\"javascript:window.open(this.getAttribute('href'), 'Tela Botanica - Remarques', config='height=700, width=640, scrollbars=yes, resizable=yes'); return false;\""
+                  + " target=\"_blank\""
+                  + ">"+Msg.get("remarques")+"</a>"
+                  + "<a href=\"#\" id=\"lienAide\">"+Msg.get("aide")+"</a>"
+                  + "</div>" ;
+  /**
+   * Booleen indiquant si utilisateur est connecte
+   *
+   */
+  public EtatConnexionVue(CarnetEnLigneMediateur cm)  {
+        carnetEnLigneMediateur=cm;
+    this.setBodyBorder(false) ;
+    this.setBorder(false) ;
+    this.setId("panneau_etat_connexion");
+        // Pas de word wrap
+        labelEtatConnexion="";
+        initialiserListeLangues();
+        this.add(listeLangues);
+        htmlEtatConnexion.setHTML(labelEtatConnexion+liens);
+        this.add(htmlEtatConnexion);
+        ajouterListeners();
+  }
+  private void initialiserListeLangues() {
+          listeLangues = new ListBox();
+          listeLangues.getElement().setId("liste_selection_langue");
+          List<String> languesDispos = Msg.getLanguesDisponibles();
+          int indexLangue = 0;
+          for (Iterator<String> iterator = languesDispos.iterator(); iterator.hasNext();) {
+                  String langue = iterator.next();
+                  listeLangues.addItem(Msg.get("intitule-langue", langue), langue);
+                  if(langue.equals(Msg.getLangue())) {
+                          listeLangues.setSelectedIndex(indexLangue);
+                  }
+                  indexLangue++;
+          }
+  }
+  private void ajouterListeners() {
+          listeLangues.addChangeHandler(new ChangeHandler() {
+                @Override
+                public void onChange(ChangeEvent event) {
+                        int indexLangue = listeLangues.getSelectedIndex();
+                        String urlCourante = Window.Location.getHref();
+                        String urlBase = urlCourante;
+                        if(urlBase.contains("?")) {
+                                urlBase = urlBase.substring(0, urlCourante.indexOf("?"));
+                        }
+                        if(urlBase.contains("#")) {
+                                urlBase = urlBase.replace("#", "");
+                        }
+                        String urlLangue = urlBase+"?lang="+listeLangues.getValue(indexLangue);
+                        Window.Location.replace(urlLangue);
+                        return;
+                }
+        });
+          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) {
+                  String[] params = {identifiant};
+                  labelEtatConnexion = "<div id=\"etatConnexion\">"+Msg.get("connecte-en-tant-que", params)+" <a id=\"lienDeconnexion\" href=\"#\">("+Msg.get("deconnexion")+")</a>" ;
+                  labelEtatConnexion += "</div>" ;
+                  labelEtatConnexion += liens ;
+                  htmlEtatConnexion.setHTML(labelEtatConnexion);
+                  ExtElement lienDeco = Ext.get("lienDeconnexion");
+                  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\"> "+Msg.get("cel-utilisation")+", <a id=\"lienConnexion\" href=\"#\">"+Msg.get("identifiez-vous")+"</a> "+Msg.get("pour-transmettre-tela")+"</div>";
+                  labelEtatConnexion += liens ;
+                  htmlEtatConnexion.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

 /trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
 New file
 ,0 → 1,205
+/**
+ 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 org.tela_botanica.client.i18n.Msg;
+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;
+        setStyleName("popup_connexion");
+    Panel panneauPrincipalDialogue=new Panel();
+    FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
+    panneauFormulaire.setTitle(Msg.get("connexion"));
+    panneauFormulaire.setWidth(350);
+    panneauFormulaire.setLabelWidth(100);
+    // Email
+    ident = new TextField(Msg.get("mail"), "ident", 200);
+    ident.setAllowBlank(false);
+    ident.setInvalidText(Msg.get("mail-vide-incorrect"));
+    ident.setTabIndex(800);
+    panneauFormulaire.add(ident);
+    // Mot de passe
+    motDePasse = new TextField(Msg.get("mot-de-passe"), "motDePasse", 200);
+    motDePasse.setAllowBlank(false);
+    ident.setInvalidText(Msg.get("mot-de-passe-vide-incorrect"));
+    motDePasse.setPassword(true);
+    motDePasse.setTabIndex(801);
+    panneauFormulaire.add(motDePasse);
+    Button boutonOK = new Button(Msg.get("ok"));
+    boutonOK.setTabIndex(802);
+    panneauFormulaire.addButton(boutonOK);
+    Button boutonAnnuler = new Button(Msg.get("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();
+                }
+            }
+    );
+    // Email
+        // 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(Msg.get("identifiant-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
+*
+*/

 /trunk/src/org/tela_botanica/client/vues/MiniBarrePaginationVue.java
 New file
 ,0 → 1,424
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.i18n.Msg;
+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.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;
+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(Msg.get("afficher")+" ");
+        /**
+         * Affichage de la page courante
+         */
+        private TextField champPage = new TextField("" + (pageCourante + 1));
+        private ToolbarTextItem surPageTotale = new ToolbarTextItem("/ ");
+        /**
+         * 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= Msg.get("obs");
+        /**
+         * taille de la page par defaut
+         *
+         */
+        private int taillePageDefaut = 50;
+        /**
+         * Texte statique de la toolbar 3
+         */
+        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(labelElement);
+        /**
+         * 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);
+                addField(champPage);
+                addItem(surPageTotale);
+                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);
+                champPage.setWidth(20);
+                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 + " "+Msg.get("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);
+                        }
+                });
+                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();
+                                }
+                        }
+                });
+        }
+        /**
+         * 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);
+                        }
+                        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);
+        }
+        /**
+         * Met à jour les affichage sur les numéros de pages et d'intervalle
+         * d'éléments à partir des variables de classes
+         */
+        public void rafraichirNumeroPage() {
+                if (nbElement == 0) {
+                        champPage.setValue("" + (0));
+                } else {
+                        champPage.setValue("" + (pageCourante + 1));
+                }
+                surPageTotale.setText("/"+pageTotale);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/BarreNotationVue.java
 New file
 ,0 → 1,237
+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;
+                        try {
+                                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();
+                                }
+                        } catch(NumberFormatException e) {
+                                // rien car pas de note (idem que le cas -1
+                                // 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

 /trunk/src/org/tela_botanica/client/vues/image/MenuImageVue.java
 New file
 ,0 → 1,190
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("plusieurs-fichiers-images-fois"));
+                        uploadSimple = new Item(Msg.get("un-fichier-image-fois"));
+                mn.addItem(uploadMultiple);
+                mn.addItem(uploadSimple);
+                // on construit le menu
+                uploaderImage = new MenuItem(Msg.get("ajouter-images"), mn);
+                supprimerImage = new Item(Msg.get("indication-supprimer-images"));
+                gestionMotsCles = new Item(Msg.get("gerer-mots-cles"));
+                ajouterImageSelection = new Item(Msg.get("ajouter-images-tampon"));
+                viderSelection = new Item(Msg.get("vider-tampon"));
+                afficherSelection = new Item(Msg.get("afficher-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

 /trunk/src/org/tela_botanica/client/vues/image/ZoomImageVue.java
 New file
 ,0 → 1,605
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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\"> "+Msg.get("indication-zoom-retour-vue-precedente")+" </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(Msg.get("mode-zoom"));
+                Toolbar tb = new Toolbar();
+                tb.addButton(modeZoom);
+                tb.addItem(valeurZoom);
+                infosTaxon = new Panel();
+                infosTaxon.setHeader(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(Msg.get("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

 /trunk/src/org/tela_botanica/client/vues/image/filtres/PanneauFiltresImagesVues.java
 New file
 ,0 → 1,210
+package org.tela_botanica.client.vues.image.filtres;
+import org.tela_botanica.client.i18n.Msg;
+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) {
+                // on utilise pas l'instance de msg car java nous l'interdit dans la premiere ligne
+                // du constructeur
+                super(Msg.get("filtres"));
+                iMediateur = im;
+                this.setCollapsible(true);
+                setLayout(new RowLayout());
+                rechercheLibreFiltreVue = new BarreRechercheFiltreVue(im);
+                rechercheLibreFiltreVue.setTitle(Msg.get("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(Msg.get("mots-cles"));
+                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

 /trunk/src/org/tela_botanica/client/vues/image/filtres/BarreRechercheFiltreVue.java
 New file
 ,0 → 1,192
+package org.tela_botanica.client.vues.image.filtres;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("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

 /trunk/src/org/tela_botanica/client/vues/image/filtres/SelectionFiltreVue.java
 New file
 ,0 → 1,98
+package org.tela_botanica.client.vues.image.filtres;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("afficher-images-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_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

 /trunk/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java
 New file
 ,0 → 1,586
+package org.tela_botanica.client.vues.image.filtres;
+import java.util.Comparator;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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
+         */
+        /**
+         * 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(Msg.get("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(Msg.get("dates"));
+                root.addListener(new TreeNodeListenerAdapter() {
+                        @Override
+                        public void onExpand(Node node) {
+                                if(!arbreCharge)
+                                {
+                                        obtenirDatesImages();
+                                        arbreCharge = true ;
+                                }
+                        }
+                }) ;
+                root.setId("racine_date");
+                String[] usObject = { Msg.get("dates"), Msg.get("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(Msg.get("dates"));
+                                String[] usObjRoot = { Msg.get("dates"), Msg.get("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 = Msg.get("inconnue") ;
+                                }
+                                if(jour.contains("00")) {
+                                        jour = Msg.get("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 Msg.get("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(Msg.get("dates"));
+                root.setId("racine_date");
+                String[] usObject = { Msg.get("dates"), Msg.get("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;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/filtres/RechercheFiltreTaxonVue.java
 New file
 ,0 → 1,120
+package org.tela_botanica.client.vues.image.filtres;
+import org.tela_botanica.client.i18n.Msg;
+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 = Msg.get("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(Msg.get("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 Msg.get("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 = "";
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java
 New file
 ,0 → 1,720
+package org.tela_botanica.client.vues.image;
+import java.util.HashMap;
+import java.util.Iterator;
+import org.tela_botanica.client.i18n.Msg;
+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.modeles.objets.Ontologies;
+import org.tela_botanica.client.util.Util;
+import org.tela_botanica.client.vues.MiniBarrePaginationVue;
+import com.google.gwt.user.client.Timer;
+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.RowSelectionModel;
+import com.gwtext.client.widgets.grid.event.GridHeaderListenerAdapter;
+import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
+import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
+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.core.SortDir;
+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 = "IDLOCLOCALITE, LIEUDIT, STATION";
+        /**
+         * Nombre de pages totales
+         */
+        private int pageMax = 1 ;
+        private SortDir directionTri;
+        private String champTri;
+        private boolean triActif;
+        /**
+         * Constructeur avec arguments
+         * @param im le médiateur à associer à la vue
+         */
+        public MiniListeObservationVue(ImageMediateur im)
+        {
+                iMediateur = im ;
+                directionTri = SortDir.ASC;
+                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","nomSaisi_observation","date_observation","lieu_observation","ordre_observation","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(Msg.get("taxon"), "nomSaisi_observation", 145, true, colRend),
+                new ColumnConfig(Msg.get("date"), "date_observation", 68, true, dateRend),
+                new ColumnConfig(Msg.get("lieu"), "lieu_observation", 145, true, colRend),
+                new ColumnConfig(Msg.get("numero"), "ordre_observation", 50, true, colRend), } ;
+        ColumnModel columnModel = new ColumnModel(columns);
+        colModel = columnModel ;
+        setTitle(Msg.get("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 = {{Msg.get("toutes-observations"),false} , {Msg.get("observations-liees"), 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(Msg.get("toutes-observations")) ;
+                selecteurMode.setEditable(false) ;
+                selecteurMode.setCls("x-selec-consult") ;
+                bt = new Toolbar() ;
+                bt.addField(selecteurMode) ;
+                //this.setAutoExpandColumn("plante");
+                setTopToolbar(bt) ;
+                this.addGridHeaderListener(new GridHeaderListenerAdapter() {
+                        @Override
+                        public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
+                                triActif = true;
+                                Timer t = new Timer() {
+                                        @Override
+                                        public void run() {
+                                                enregistrerEtatTri();
+                                                // Trier ne change pas le nombre de pages, on peut donc se passer d'un appel
+                                                // au comptage (ce serait mieux si ces deux appels étaient combinés)
+                                                obtenirMiniListeObservations();
+                                        }
+                                };
+                                // Le changement de tri n'est pas immédiat et si on recharge le liste tout de suite
+                                // on a l'ancien tri et pas le nouveau (200 millisecondes suffisent et ne se voient pas)
+                                // #mondeDeMerde
+                                t.schedule(200);
+                        }
+                });
+                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 selectionne 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()) ;
+                        }
+                }) ;
+                // TODO: voir s'il existe un autre moyen de désactiver la multiselection
+                // ça semble bien compliqué de faire comme ça
+                getSelectionModel().addListener(new RowSelectionListenerAdapter() {
+                        @Override
+                        public boolean doBeforeRowSelect(RowSelectionModel sm, int rowIndex,
+                                        boolean keepExisting, Record record) {
+                                sm.clearSelections();
+                                return true;
+                        }
+                });
+                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(Msg.get("glissez-deposer-obs-images")) ;
+                //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","nomSaisi_observation","date_observation","lieu_observation","ordre_observation","id_obs"}, listeObs);
+                                store.sort(champTri, directionTri);
+                                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(Msg.get("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(Msg.get("lier-images-selectionnes"));
+                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;
+                }
+        }
+        private void enregistrerEtatTri() {
+                if(triActif) {
+                        this.directionTri = store.getSortState().getDirection();
+                        this.champTri = store.getSortState().getField();
+                }
+        }
+        public String renvoyerTri() {
+                String tri = "ordre";
+                if(triActif) {
+                        HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri();
+                        if(corr.containsKey(champTri)) {
+                                tri = corr.get(champTri);
+                        }
+                }
+                return tri;
+        }
+        public String renvoyerDirectionTri() {
+                String triDir = "ASC";
+                try {
+                        triDir = (triActif) ? directionTri.getDirection() : "ASC";
+                } catch (Exception e) {
+                        triDir = "ASC";
+                }
+                return triDir;
+        }
+}
 Property changes:
 Added: svn:mergeinfo

 /trunk/src/org/tela_botanica/client/vues/image/PanneauMetadonneesVue.java
 New file
 ,0 → 1,526
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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();
+                // TODO : un bug mystérieux n'apparait que lorsqu'on compile
+                // en obfuscated et empêche de consulter les exifs et iptc
+                // on associe le médiateur
+                imediateur = im;
+                // on crée et dispose les panneaux et les champs
+                panneauExifGrid = new Panel(Msg.get("infos-exif"));
+                panneauIptcGrid = new Panel(Msg.get("infos-iptc"));
+                panneauInfoGrid = new Panel(Msg.get("infos-generales"));
+                panneauMotsCles = new ImageMotsClesVue(im);
+                panneauMotsCles.setHeight("50%");
+                Panel sousPanneauInfosGenerales = new Panel(Msg.get("infos-generales"));
+                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(Msg.get("commentaires")+" :");
+                labelComm.setHeight("20px");
+                commentaireGeneral = new TextArea();
+                commentaireGeneral.setWidth("90%");
+                Label labelDate = new Label(Msg.get("date")+" :");
+                Label labelNote = new Label(Msg.get("note")+" :");
+                panneauMotsCles.setBorder(false);
+                labelDate.setHeight("20px");
+                dateImage = new DateField();
+                dateImage.setAutoWidth(true);
+                dateImage.setFormat("d/m/Y");
+                validerInfo = new Button(Msg.get("ok"));
+                noteVue = new BarreNotationVue(im, 5);
+                panneauMiniListeObservation = new Panel(Msg.get("observations")) ;
+                if(!Ext.isIE()) {
+                        panneauMiniListeObservation.setLayout(new RowLayout());
+                }
+                miniListeObservation = new MiniListeObservationVue(im);
+                rechercheFiltreTaxonVue = new RechercheFiltreTaxonVue(im);
+                rechercheFiltreTaxonVue.setTitle(Msg.get("recherche-dans-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(Msg.get("exif-metadonnees"));
+                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(Msg.get("iptc-metadonnees"));
+                IptcGrid.setAutoWidth(true);
+                IptcGrid.setHeight(500);
+                IptcGrid.setSorted(false);
+                IptcGrid.setAutoScroll(true);
+                panneauExifGrid.add(ExifGrid);
+                panneauIptcGrid.add(IptcGrid);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        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

 /trunk/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java
 New file
 ,0 → 1,235
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.cel2;
+import org.tela_botanica.client.i18n.Msg;
+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);
+                texteFiltres = new ToolbarTextItem("");
+                final ToolbarMenuButton menuImage = new ToolbarMenuButton(Msg.get("ajouter-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(Msg.get("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(Msg.get("gerer-mots-cles"));
+                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);
+        }
+        /**
+         * @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\"> "+Msg.get("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 = Msg.get("mots-cles");
+                } else {
+                        nomFiltre = Msg.get(nomFiltre);
+                }
+                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

 /trunk/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java
 New file
 ,0 → 1,692
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.util.MotsClesUtilitaire;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.NodeTraversalCallback;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.dd.DragData;
+import com.gwtext.client.dd.DragDrop;
+import com.gwtext.client.widgets.Button;
+import com.gwtext.client.widgets.Component;
+import com.gwtext.client.widgets.Container;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.Toolbar;
+import com.gwtext.client.widgets.ToolbarButton;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.event.WindowListenerAdapter;
+import com.gwtext.client.widgets.form.TextField;
+import com.gwtext.client.widgets.layout.FitLayout;
+import com.gwtext.client.widgets.layout.HorizontalLayout;
+import com.gwtext.client.widgets.layout.RowLayout;
+import com.gwtext.client.widgets.layout.RowLayoutData;
+import com.gwtext.client.widgets.tree.MultiSelectionModel;
+import com.gwtext.client.widgets.tree.TreeEditor;
+import com.gwtext.client.widgets.tree.TreeNode;
+import com.gwtext.client.widgets.tree.TreePanel;
+import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
+import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
+/**
+ * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
+ * clés cochables et réorganisables à volonté
+ *
+ * @author aurelien
+ *
+ */
+public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable {
+        /**
+         * Le treepanel qui affiche l'arbre
+         */
+        private TreePanel arbreMotsCles = null;
+        /**
+         * L'éditeur qui permet de modifier les mots clés dans l'arbre
+         */
+        private TreeEditor te = null;
+        /**
+         * Le textfield associé à l'éditeur
+         */
+        private TextField tfEdit = null;
+        /**
+         * Bouton de validation
+         */
+        private Button valider = null;
+        /**
+         * Bouton d'annulation
+         */
+        private Button annuler = null;
+        /**
+         * Bouton d'ajout de tag
+         */
+        private ToolbarButton ajouterTag = null;
+        /**
+         * Bouton de suppression de tag
+         */
+        private ToolbarButton supprimerTag = null;
+        /**
+         * Bouton de renommage de tag
+         */
+        private ToolbarButton renommerTag = null;
+        /**
+         * Une string permettant connaitre les mots clés cochés en cours séparés par
+         * des virgules
+         */
+        private String motsClesEnCours = "";
+        private String[] tableauMotsClesEnCours = new String[0];
+        /**
+         * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
+         * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
+         * du conteneur n'ai été effectué)
+         */
+        private String[] motsClesEnAttente = new String[0];
+        /**
+         * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
+         * noeud
+         */
+        private boolean ajoutNoeud = false;
+        /**
+         * Booléen d'évènement qui sert à savoir si on est en train de modifier un
+         * noeud
+         */
+        private boolean modifNoeud = false;
+        /**
+         * Booléen d'instanciation du conteneur
+         */
+        private boolean arbreCharge = false;
+        /**
+         * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
+         */
+        private boolean motsCleInitialises;
+        /**
+         * panneau intermédiaire contenant l'arbre
+         */
+        private Panel panelIntermediaire;
+        private String cheminTemporaireAjout;
+        /**
+         * Constructeur avec paramètre
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public FenetreGestionMotsCles() {
+                // on crée le panel
+                setTitle(Msg.get("mots-cles-arbre"));
+                this.setLayoutData(new RowLayout());
+                // on crée le conteneur de l'arbre
+                arbreMotsCles = new TreePanel();
+                // on permet le drag and drop dans l'arbre
+                arbreMotsCles.setEnableDD(true);
+                arbreMotsCles.setId("x-view-tree-keyword-imgs");
+                arbreMotsCles.setSelectionModel(new MultiSelectionModel());
+                // on crée une racine pour l'arbre
+                TreeNode root = new TreeNode("Tags");
+                root.setId("racine");
+                String[] usObject = {Msg.get("mots-cles-maj"), "racine" };
+                root.setExpandable(true);
+                arbreMotsCles.setRootNode(root);
+                arbreMotsCles.setRootVisible(true);
+                arbreMotsCles.setBorder(false);
+                arbreMotsCles.setWidth(500);
+                root.setUserObject(usObject);
+                arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
+                        @Override
+                        public void onClick(Node node, EventObject e) {
+                                if(!arbreCharge) {
+                                        expand();
+                                }
+                        }
+                        @Override
+                        public void onExpand(Node node) {
+                                if(!arbreCharge) {
+                                        obtenirArbreMotsCles();
+                                        arbreCharge = true;
+                                }
+                        }
+                });
+                // on crée l'éditeur pour l'arbre
+                tfEdit = new TextField();
+                tfEdit.setAutoWidth(true);
+                te = new TreeEditor(arbreMotsCles, tfEdit);
+                valider = new Button(Msg.get("appliquer"));
+                annuler = new Button(Msg.get("annuler"));
+                arbreMotsCles.add(te);
+                panelIntermediaire = new Panel();
+                panelIntermediaire.setLayout(new FitLayout());
+                panelIntermediaire.setAutoScroll(true);
+                panelIntermediaire.setWidth("100%");
+                arbreMotsCles.setWidth("100%");
+                arbreMotsCles.setHeight("100%");
+                Panel panelBoutons = new Panel();
+                panelBoutons.setLayout(new HorizontalLayout(130));
+                panelBoutons.setWidth("100%");
+                // on met en forme le layout
+                panelIntermediaire.add(arbreMotsCles);
+                panelBoutons.add(annuler);
+                panelBoutons.add(valider);
+                this.add(panelIntermediaire, new RowLayoutData());
+                this.add(panelBoutons, new RowLayoutData(30));
+                arbreMotsCles.setHeight("100%");
+                arbreMotsCles.setAutoScroll(true);
+                Toolbar barreBouton = new Toolbar();
+                ajouterTag = new ToolbarButton(Msg.get("nouveau-tag"));
+                ajouterTag.setIcon("mot_cle_ajouter.png");
+                renommerTag = new ToolbarButton(Msg.get("renommer"));
+                renommerTag.setIcon("mot_cle_editer.png");
+                renommerTag.disable();
+                supprimerTag = new ToolbarButton(Msg.get("supprimer"));
+                supprimerTag.setIcon("mot_cle_supprimer.png");
+                supprimerTag.disable();
+                barreBouton.addButton(ajouterTag);
+                barreBouton.addSeparator();
+                barreBouton.addButton(renommerTag);
+                barreBouton.addSeparator();
+                barreBouton.addButton(supprimerTag);
+                this.setTopToolbar(barreBouton);
+                setCloseAction(com.gwtext.client.widgets.Window.HIDE);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Acesseur pour l'arbre des mots clés
+         *
+         * @return le panel contenant l'arbre
+         */
+        public TreePanel getArbreMotsCles() {
+                return arbreMotsCles;
+        }
+        /**
+         * Accesseur pour l'éditeur
+         *
+         * @return l'éditeur associé à l'arbre
+         */
+        public TreeEditor getTe() {
+                return te;
+        }
+        /**
+         * Acesseur pour le TextField associé à l'éditeur
+         *
+         * @return le champ texte associé à l'éditeur
+         */
+        public TextField getTfEdit() {
+                return tfEdit;
+        }
+        protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te);
+        protected abstract void surAjoutMotCle(TreeNode node, Tree arbre);
+        protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre);
+        protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre);
+        protected abstract void surChangementTexte(TreeNode node, Tree arbre);
+        protected abstract void surClicValider(String chaineMotsCles, Tree arbre);
+        protected abstract void demanderArbreMotsCles(Rafraichissable r);
+        protected abstract void surRetourWebService(Tree arbre);
+        /**
+         * Ajoute les listeners nécessaires pour la gestion des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new WindowListenerAdapter() {
+                        @Override
+                        public void onResize(com.gwtext.client.widgets.Window source, int width,
+                                        int height) {
+                                        panelIntermediaire.setHeight(getHeight() - 80);
+                        }
+                });
+                arbreMotsCles.addListener(new TreePanelListenerAdapter() {
+                        @Override
+                        public void onAfterLayout(Container self) {
+                                panelIntermediaire.setHeight(getHeight() - 80);
+                        }
+                        @Override
+                        public void onExpandNode(TreeNode node) {
+                                cocherMotsCles(tableauMotsClesEnCours);
+                        }
+                        // gestion du clic sur un noeud
+                        @Override
+                        public void onClick(TreeNode node, EventObject e) {
+                                e.stopEvent();
+                                gererClicNoeud(node);
+                                if(!node.equals(arbreMotsCles.getRootNode())) {
+                                        supprimerTag.enable();
+                                        renommerTag.enable();
+                                }
+                        }
+                        // gestion du clic droit sur un noeud
+                        @Override
+                        public void onContextMenu(TreeNode node, EventObject e) {
+                                e.stopEvent();
+                                surAffichageMenuContextuel(node, e, getTe());
+                                if(!node.equals(arbreMotsCles.getRootNode())) {
+                                        supprimerTag.enable();
+                                        renommerTag.enable();
+                                }
+                        }
+                        // gestion de la modification du texte d'un noeud
+                        @Override
+                        public void onTextChange(TreeNode node, String text, String oldText) {
+                                if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
+                                        te.startEdit(node);
+                                        Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
+                                        return;
+                                }
+                                if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
+                                        te.startEdit(node);
+                                        Window.alert("Un mot clé de même nom existe déjà à cette position");
+                                        return;
+                                }
+                                if(node.equals(arbreMotsCles.getRootNode())) {
+                                        return;
+                                }
+                                // on récupère les informations associées au noeud
+                                TreeNode nd = node;
+                                String[] usObject = new String[2];
+                                usObject[0] = text;
+                                usObject[1] = ((String[]) nd.getUserObject())[1];
+                                nd.setUserObject(usObject);
+                                // si c'est un nouveau noeud
+                                if (ajoutNoeud) {
+                                        // on considère l'ajout achevé
+                                        ajoutNoeud = false;
+                                        // et on notifie le médiateur de l'ajout et on lui passe
+                                        // l'arbre
+                                        surAjoutMotCle(nd, getArbreMotsCles().getTree());
+                                        arbreMotsCles.disable();
+                                }
+                                // si c'est noeud déjà existant
+                                else {
+                                        // on considère la modification achevée
+                                        modifNoeud = false;
+                                        if(!text.equals(oldText)) {
+                                                // et on notifie le médiateur de la modification et on lui
+                                                // passe l'arbre
+                                                surChangementTexte(nd, getArbreMotsCles().getTree());
+                                                arbreMotsCles.disable();
+                                        }
+                                }
+                        }
+                        @Override
+                        public boolean doBeforeMoveNode(Tree tree, TreeNode node,
+                                        TreeNode oldParent, TreeNode newParent, int index) {
+                                boolean ok = true;
+                                if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
+                                        ok = false;
+                                        Window.alert("Un mot clé de même nom existe déjà à cette position");
+                                }
+                                return ok;
+                        }
+                        @Override
+                        public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
+                                        DragData dragData, String point, DragDrop source,
+                                        TreeNode dropNode) {
+                                return MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
+                        }
+                        // gestion du déplacement d'un noeud
+                        @Override
+                        public void onMoveNode(Tree tree, TreeNode node,
+                                        TreeNode oldParent, TreeNode newParent, int index) {
+                                // on notifie le médiateur et on lui passe l'arbre
+                                surDeplacementMotCle(node, getArbreMotsCles().getTree());
+                        }
+                });
+                // gestion de la validation
+                valider.addListener(new ButtonListenerAdapter() {
+                        // lors du clic
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                // on vide les mots clés en cours
+                                motsClesEnCours = "";
+                                // pour chaque noeud à partir de la racine
+                                getArbreMotsCles().getRootNode().cascade(
+                                                new NodeTraversalCallback() {
+                                                        // on éxécute une fonction
+                                                        @Override
+                                                        public boolean execute(Node node) {
+                                                                // on récupère le mot clé associé au noeud et
+                                                                // ses infos
+                                                                TreeNode tn = getArbreMotsCles().getNodeById(
+                                                                                node.getId());
+                                                                String[] usObject = (String[]) tn
+                                                                                .getUserObject();
+                                                                /*getIMediateur().mettreAjourMotsClesId(
+                                                                                usObject[0], usObject[1]);*/
+                                                                if (tn.getUI().isChecked()) {
+                                                                        // et les concatène à la string des mots
+                                                                        // clés en cours
+                                                                        motsClesEnCours += usObject[1] + ",";
+                                                                }
+                                                                return true;
+                                                        }
+                                                });
+                                // enfin on notifie le médiateur et on lui passe l'arbre et la
+                                // liste des mots clés ainsi obtenue
+                                surClicValider(motsClesEnCours, arbreMotsCles.getTree());
+                        }
+                });
+                annuler.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                hide();
+                        }
+                });
+                renommerTag.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
+                                TreeNode noeudRenommage;
+                                if(noeuds.length > 0) {
+                                        noeudRenommage = noeuds[noeuds.length - 1];
+                                } else {
+                                        noeudRenommage = arbreMotsCles.getRootNode();
+                                }
+                                renommerNoeud(noeudRenommage);
+                        }
+                });
+                ajouterTag.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
+                                TreeNode noeudAjout;
+                                if(noeuds.length > 0) {
+                                        noeudAjout = noeuds[noeuds.length - 1];
+                                } else {
+                                        noeudAjout = arbreMotsCles.getRootNode();
+                                }
+                                ajouterNoeud(noeudAjout);
+                        }
+                });
+                supprimerTag.addListener(new ButtonListenerAdapter() {
+                        @Override
+                        public void onClick(Button button, EventObject e) {
+                                TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
+                                for (int i = 0; i < noeuds.length; i++) {
+                                        supprimerNoeud(noeuds[i]);
+                                }
+                        }
+                });
+        }
+        /**
+         * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
+         */
+        public void obtenirArbreMotsCles() {
+                demanderArbreMotsCles(this);
+        }
+        /**
+         * Supprime un noeud de l'arbre
+         *
+         * @param n
+         *            le noeud à supprimer
+         */
+        public void supprimerNoeud(TreeNode n) {
+                // si ça n'est pas la racine (qu'on ne peut pas supprimer)
+                if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
+                        if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
+                                // on détache le noeud et on le détruit
+                                n.getParentNode().removeChild(n);
+                                n.destroy();
+                                // puis on en notifie le médiateur en lui passant le noeud supprimé
+                                // et l'arbre
+                                surSuppressionMotCle(n, arbreMotsCles.getTree());
+                        }
+                } else {
+                        // si l'utilisateur tente de supprimer la racine, on l'avertit de
+                        // son erreur
+                        Window.alert("Impossible de supprimer la racine de l'arbre");
+                }
+        }
+        /**
+         * Ajoute un noeud dans l'arbre au parent donné
+         *
+         * @param parent
+         *            le futur parent du noeud à ajouter
+         */
+        public void ajouterNoeud(TreeNode parent) {
+                ajoutNoeud = true;
+                TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
+                // on le concatène au parent et on étend ses enfants
+                parent.appendChild(nd);
+                parent.expand();
+                cheminTemporaireAjout = nd.getId();
+                te.startEdit(nd);
+        }
+        /**
+         * Renomme le noeud passé en paramètre
+         */
+        public void renommerNoeud(TreeNode n) {
+                // TODO Auto-generated method stub
+                te.startEdit(n);
+        }
+        /**
+         * Coche le noeud s'il est décoché, le décoche sinon
+         *
+         * @param node
+         */
+        public void gererClicNoeud(TreeNode node) {
+                if (node.getUI().isChecked()) {
+                        node.getUI().toggleCheck(false);
+                } else {
+                        node.getUI().toggleCheck(true);
+                }
+        }
+        /**
+         * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
+         * clés à cocher
+         *
+         * @param motsClesIds
+         *            un tableau contenant les identifiants des mots clés à cocher
+         */
+        public void cocherMotsCles(final String[] motsClesIds) {
+                if (getArbreMotsCles() != null
+                                && getArbreMotsCles().getRootNode() != null) {
+                        // à partir de la racine
+                        getArbreMotsCles().getRootNode().cascade(
+                                new NodeTraversalCallback() {
+                                        // pour chaque noeud
+                                        @Override
+                                        public boolean execute(Node node) {
+                                                String usObject[] = (String[]) node
+                                                                .getUserObject();
+                                                String nodeId = usObject[1];
+                                                TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
+                                                if(tn != null) {
+                                                        tn.getUI().toggleCheck(false);
+                                                        // on parcourt le tableau des mots clés
+                                                        for (int i = 0; i < motsClesIds.length; i++) {
+                                                                // si le mot clé fait partie des id à cocher on
+                                                                // le coche
+                                                                if (nodeId.equals(motsClesIds[i])) {
+                                                                        tn.getUI().toggleCheck(true);
+                                                                        tn.ensureVisible();
+                                                                        return true;
+                                                                }
+                                                        }
+                                                        // et on passe au suivant
+                                                }
+                                                return true;
+                                        }
+                                });
+                }
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         *
+         * @param nouvelleDonnees
+         *            les nouvelles données pour l'objet
+         * @param repandreRafraichissement
+         *            booleen qui dit si on doit répandre l'évenement
+         */
+        @Override
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                if(nouvelleDonnees instanceof Tree) {
+                        Tree nouvelArbre = (Tree)nouvelleDonnees ;
+                        // on prend sa racine et on l'attache à l'arbre des mots clés
+                        Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
+                        for (int i = 0; i < rootChild.length; i++) {
+                                rootChild[i].remove();
+                        }
+                        copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
+                        // si l'arbre n'était pas encore considéré comme instancié
+                        if (!arbreCharge) {
+                                // on signale que oui
+                                arbreCharge = true;
+                        }
+                }
+                // Si on reçoit un tableau de String (cas ou l'on séléectionne une
+                // nouvelle image)
+                if (nouvelleDonnees instanceof String[]) {
+                        // le tableau de String contient les id des mots clés associés à
+                        // l'image
+                        // on coche les mots clés contenu dans le tableau
+                        tableauMotsClesEnCours = (String[]) nouvelleDonnees;
+                        if(this.isVisible()) {
+                                cocherMotsCles(tableauMotsClesEnCours);
+                        } else {
+                                addListener(new WindowListenerAdapter() {
+                                        @Override
+                                        public void onShow(Component component) {
+                                                cocherMotsCles(tableauMotsClesEnCours);
+                                        }
+                                });
+                        }
+                }
+                // reception d'un nouvel identifiant de mot clé
+                if(nouvelleDonnees instanceof Integer) {
+                        if(cheminTemporaireAjout != null) {
+                                String id = ((Integer)(nouvelleDonnees)).toString();
+                                TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
+                                String[] userObj = {noeudEnAjout.getText(), id};
+                                noeudEnAjout.setUserObject(userObj);
+                                cheminTemporaireAjout = null;
+                        }
+                }
+                surRetourWebService(arbreMotsCles.getTree());
+                arbreMotsCles.enable();
+        }
+        /**
+         * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
+         * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
+         *
+         * @param ndPereOriginal
+         *            le père des noeuds de l'arbre original
+         * @param ndPereCopie
+         *            le père qui va recevoir les copies
+         */
+        private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
+                if (ndPereCopie != null && ndPereOriginal != null) {
+                        Node[] ndNodeFils = ndPereOriginal.getChildNodes();
+                        for (int i = 0; i < ndNodeFils.length; i++) {
+                                String[] usObj = (String[]) ndNodeFils[i].getUserObject();
+                                TreeNode child = new TreeNode(usObj[0]);
+                                child.setId(usObj[1]);
+                                child.setChecked(false);
+                                child.setUserObject(usObj);
+                                ndPereCopie.appendChild(child);
+                                if (!ndNodeFils[i].isLeaf()) {
+                                        copierFilsNoeud(ndNodeFils[i], child);
+                                }
+                        }
+                }
+        }
+        public void activerBoutonValider(boolean activer) {
+                valider.setVisible(activer);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/GalerieImageVue.java
 New file
 ,0 → 1,575
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("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(Msg.get("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(Msg.get("chargement"));
+                this.add(dView);
+                dView.hide();
+                videPanel = new HTML("<div class=\"avertissement\" >"+Msg.get("avertissement-aucune-image")+". <br/> <a id=\"lienUploadMultiple\" href=\"#\" > "+Msg.get("cliquez-plusieurs-fichiers-images-fois")+" </a> ("+Msg.get("necessite-java")+") <br/> " +
+                                "                       <a id=\"lienUploadSimple\" href=\"#\" > "+Msg.get("cliquez-un-fichier-image-fois")+" </a> <br/> " +
+                                "                       "+Msg.get("indication-ajouter-images-plus-tard")+" </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;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/ImageMotsClesVue.java
 New file
 ,0 → 1,97
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("mots-cles"));
+                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);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/image/MenuIdVue.java
 New file
 ,0 → 1,86
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("changer-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

 /trunk/src/org/tela_botanica/client/vues/image/OptionsImages.java
 New file
 ,0 → 1,211
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("plusieurs-fichiers-images-fois"));
+                uploadSimple = new Item(Msg.get("un-fichier-image-fois"));
+                mnFichiers.addItem(uploadMultiple);
+                mnFichiers.addItem(uploadSimple);
+                // on construit le menu
+                uploaderImage = new MenuItem(Msg.get("ajouter-images"), mnFichiers);
+                supprimerImage = new ToolbarButton(Msg.get("supprimer"));
+                ajouterImageSelection = new Item(Msg.get("ajouter-images-tampon"));
+                viderSelection = new Item(Msg.get("vider-tampon"));
+                afficherSelection = new Item(Msg.get("afficher-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(Msg.get("indication-utilisation-tampon"));
+                // 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(Msg.get("indication-supprimer-images"));
+                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(Msg.get("indication-plusieurs-fichiers-images-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

 /trunk/src/org/tela_botanica/client/vues/image/ListeImageVue.java
 New file
 ,0 → 1,795
+package org.tela_botanica.client.vues.image;
+import java.util.HashMap;
+import org.tela_botanica.client.i18n.Msg;
+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.modeles.objets.Ontologies;
+import org.tela_botanica.client.util.Util;
+import org.tela_botanica.client.vues.BarrePaginationVue;
+import com.google.gwt.user.client.Timer;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.core.SortDir;
+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.GridHeaderListenerAdapter;
+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;
+        private SortDir directionTri;
+        private String champTri;
+        private boolean triActif;
+        /**
+         * 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(Msg.get("images"));
+                bt.setTaillePageParDefaut(50);
+                setBottomToolbar(bt);
+                directionTri = SortDir.ASC;
+                // on construit le modèle de colonnes
+                numImage = new ColumnConfig(Msg.get("numero"), "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("   ", "transmis", 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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("nom-associe"), "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);
+                RecordDef rd = new RecordDef(ImageMediateur.getDefinitionsChampsGrilleImages());
+                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.addGridHeaderListener(new GridHeaderListenerAdapter() {
+                        @Override
+                        public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
+                                triActif = true;
+                                Timer t = new Timer() {
+                                        @Override
+                                        public void run() {
+                                                enregistrerEtatTri();
+                                                // Trier ne change pas le nombre de page, on peut donc se passer d'un appel
+                                                // au comptage (ce serait mieux si ces deux appels étaient combinés)
+                                                iMediateur.obtenirPhotoGalerieSansCalculerPages(ListeImageVue.this);
+                                        }
+                                };
+                                // Le changement de tri n'est pas immédiat et si on recharge le liste tout de suite
+                                // on a l'ancien tri et pas le nouveau (200 millisecondes suffisent et ne se voient pas)
+                                // #mondeDeMerde
+                                t.schedule(200);
+                        }
+                });
+                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(Msg.get("glissez-deposer-images-obs")) ;
+                                        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.sort(champTri, directionTri);
+                        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;
+        }
+        private void enregistrerEtatTri() {
+                if(triActif) {
+                        this.directionTri = st.getSortState().getDirection();
+                        this.champTri = st.getSortState().getField();
+                }
+        }
+        public String renvoyerTri() {
+                String tri = "ordre";
+                if(triActif) {
+                        HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleImageChampsTri();
+                        if(corr.containsKey(champTri)) {
+                                tri = corr.get(champTri);
+                        }
+                }
+                return tri;
+        }
+        public String renvoyerDirectionTri() {
+                String triDir = "ASC";
+                try {
+                        triDir = (triActif) ? directionTri.getDirection() : "ASC";
+                } catch (Exception e) {
+                        triDir = "ASC";
+                }
+                return triDir;
+        }
+}
 Property changes:
 Added: svn:mergeinfo

 /trunk/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java
 New file
 ,0 → 1,149
+package org.tela_botanica.client.vues.image;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("lier-images-selection-obs"));
+                lierSelectionTampon = new Item(Msg.get("lier-tampon-selection-obs"));
+                afficherSelection = new Item(Msg.get("afficher-tampon"));
+                addItem(lierSelection);
+                addItem(lierSelectionTampon);
+                addItem(afficherSelection);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        public MenuLiaisonVue(ImageMediateur im, boolean liaison) {
+                iMediateur = im;
+                lierSelection = new Item(Msg.get("lier-images-selection-obs"));
+                lierSelectionTampon = new Item(Msg.get("lier-tampon-selection-obs"));
+                afficherSelection = new Item(Msg.get("afficher-tampon"));
+                addItem(lierSelection);
+                addItem(lierSelectionTampon);
+                addItem(afficherSelection);
+                iMediateur = im;
+                if(liaison) {
+                        supprimerLiaison = new Item(Msg.get("supprimer-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

 /trunk/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java
 New file
 ,0 → 1,234
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.objets.Utilisateur;
+import com.google.gwt.user.client.Timer;
+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.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;
+        private Timer timerCompletion = null;
+        public ListeUtilisateurAdminVue(CarnetEnLigneMediateur cMed) {
+                super(Msg.get("choisir-utilisateur")) ;
+                this.cMediateur = cMed;
+                listeUtil=new ComboBox(Msg.get("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(Msg.get("en-recherche")+"...");
+                listeUtil.setValue(utilisateur);
+                OK= new com.gwtext.client.widgets.Button(Msg.get("ok"));
+                annuler = new com.gwtext.client.widgets.Button(Msg.get("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();
+                        }
+                });
+            ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
+            listenerConfigAutocompletion.setDelay(200);
+            listenerConfigAutocompletion.setStopPropagation(false);
+            listenerConfigAutocompletion.setStopEvent(false);
+                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:
+                                if(timerCompletion != null) {
+                                        timerCompletion.cancel();
+                                }
+                                timerCompletion = new Timer() {
+                                                        public void run() {
+                                                obtenirListeUtilisateur();
+                                                        }
+                                };
+                                timerCompletion.schedule(250);
+                            break;
+                                }
+                        }
+                }, listenerConfigAutocompletion);
+                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);
+                        // Tentative de corriger un bug insupportable de la taille de la liste
+                        // mais ça ne marche pas à tous les coups
+                        listeUtil.collapse();
+                        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:ignore
 +.project
 +tomcat
 Added: svn:mergeinfo
 Merged /branches/v1.0-beche/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java:r290-316

 /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
 New file
 ,0 → 1,468
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.i18n.Msg;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.util.MotsClesUtilitaire;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.NodeTraversalCallback;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.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;
+        private String cheminTemporaireAjout;
+        /**
+         * 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(Msg.get("mots-cles-arbre"));
+                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(Msg.get("tags"));
+                root.setId("racine");
+                String[] usObject = {Msg.get("mots-cles-arbre"), "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(Msg.get("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() {
+                final Rafraichissable r = this;
+                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(), ArbreMotsClesVue.this);
+                                }
+                                // 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(), ArbreMotsClesVue.this);
+                                }
+                        }
+                        // 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(), ArbreMotsClesVue.this);
+                        }
+                });
+                // 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(), ArbreMotsClesVue.this);
+                } else {
+                        // si l'utilisateur tente de supprimer la racine, on l'avertit de
+                        // son erreur
+                        Window.alert(Msg.get("impossible-supprimer-racine"));
+                }
+        }
+        /**
+         * Ajoute un noeud dans l'arbre au parent donné
+         *
+         * @param parent
+         *            le futur parent du noeud à ajouter
+         */
+        public void ajouterNoeud(TreeNode parent) {
+                ajoutNoeud = true;
+                TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);
+                // on le concatène au parent et on étend ses enfants
+                parent.appendChild(nd);
+                parent.expand();
+                cheminTemporaireAjout = nd.getId();
+                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();
+                        }
+                        MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), true);
+                        // 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);
+                }
+                // reception d'un nouvel identifiant de mot clé
+                if(nouvelleDonnees instanceof Integer) {
+                        if(cheminTemporaireAjout != null) {
+                                String id = ((Integer)(nouvelleDonnees)).toString();
+                                TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
+                                String[] userObj = {noeudEnAjout.getText(), id};
+                                noeudEnAjout.setUserObject(userObj);
+                                noeudEnAjout.setId(id);
+                                cheminTemporaireAjout = null;
+                        }
+                }
+                arbreMotsCles.enable();
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/BarrePaginationVue.java
 New file
 ,0 → 1,489
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("page")+" ");
+        /**
+         * Affichage de la page courante
+         */
+        private TextField champPage = new TextField("" + (pageCourante + 1));
+        /**
+         * Affichage de "sur pageTotale "
+         */
+        private ToolbarTextItem surTotalPage = new ToolbarTextItem(" "+Msg.get("sur")+" "
+                        + pageTotale);
+        /**
+         * Texte statique de la toolbar 2
+         */
+        private ToolbarTextItem afficherNbElem = new ToolbarTextItem(Msg.get("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= Msg.get("elements");
+        /**
+         * taille de la page par defaut
+         *
+         */
+        private int taillePageDefaut = 50;
+        /**
+         * Texte statique de la toolbar 3
+         */
+        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
+                        labelElement+" "+Msg.get("par-page")+" ");
+        /**
+         * Affiche l'intervalle des éléments contenus dans la page
+         */
+        private ToolbarTextItem intervalleElements = new ToolbarTextItem(labelElement + " "
+                        + pageCourante * taillePage + " "+Msg.get("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 + " "+Msg.get("par-page")+" ");
+                intervalleElements.setText(labelElement + " " + pageCourante * taillePage + " "+Msg.get("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(" "+Msg.get("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 "+Msg.get("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
+                                                + " "+Msg.get("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 + " "+Msg.get("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

 /trunk/src/org/tela_botanica/client/vues/MenuAideVue.java
 New file
 ,0 → 1,95
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.i18n.Msg;
+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(Msg.get("aide"));
+                bugRemarque = new Item(Msg.get("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;
+        }
+}

 /trunk/src/org/tela_botanica/cel-test.gwt.xml
 New file
 ,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>

 /trunk/src/org/tela_botanica/cel2.gwt.xml
 New file
 ,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.maps.gwt.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>

/trunk/war/modele_import.xls
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/war/GwtExt.css
 New file
 ,0 → 1,56
+#loading {
+    position: absolute;
+    left: 45%;
+    top: 40%;
+    padding: 2px;
+    z-index: 20001;
+    height: auto;
+    border: 1px solid #ccc;
+}
+#loading a {
+    color: #225588;
+}
+#loading .loading-indicator {
+    background: white;
+    color: #444;
+    font: bold 13px tahoma, arial, helvetica;
+    padding: 10px;
+    margin: 0;
+    height: auto;
+}
+#loading-msg {
+    font: normal 10px arial, tahoma, sans-serif;
+}
+.x-portlet {
+    margin-bottom:10px;
+}
+.x-portal .x-panel-dd-spacer {
+    margin-bottom:10px;
+}
+/*
+ * FF3 grid support
+ */
+.x-grid3 table {
+    table-layout:fixed;
+}
+/*
+ * FF3 calendar support
+ */
+div.x-date-picker {
+    width:10px;
+}
+/*
+ * FF2 / FF3 issue with scrolling when having an EditorGridPanel
+ */
+.ext-gecko .x-grid-editor {
+        position: relative !important;
+        float: left;
+}

 /trunk/war/cel2.css
 New file
 ,0 → 1,641
+/** Add css rules here for your application. */
+body,td,a,div,.p {
+        font-family: arial, sans-serif
+}
+div,td {
+        color: #000000
+}
+a:link,.w,.w a:link {
+        color: #0000cc
+}
+a:visited {
+        color: #551a8b
+}
+a:active {
+        color: #ff0000
+}
+.thumb-wrap {
+        width: 100px;
+        height: 130px;
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+        background-color: #DCDCDC;
+        border-width: 1px;
+        border-style: solid;
+        border-color: #667A6B;
+        overflow: hidden;
+        position: relative;
+}
+miniature_galerie {
+        z-index: 35;
+}
+.picto_haut_gauche {
+        position: absolute;
+        top: 2px;
+        left: 2px;
+        z-index: 40;
+}
+.picto_haut_droite {
+        position: absolute;
+        top: 2px;
+        right: 2px;
+        z-index: 40;
+}
+.x-window-tl .x-window-header {
+        color: #4A6438;
+}
+.x-window-mc {
+        background-color: #FFFFFF;
+}
+.x-panel-header {
+        color: #FFFFFF;
+}
+.x-tab-strip span.x-tab-strip-text {
+        color: #FFFFFF;
+}
+.x-tab-strip-active span.x-tab-strip-text {
+        color: #4A6438;
+        cursor: default;
+        font-weight: bold;
+}
+.img-list {
+        height: 50px;
+        width: 50px;
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+}
+.dview-list {
+        display: table-cell;
+        height: auto;
+        padding-bottom: 10px;
+        text-align: center;
+        vertical-align: middle;
+        width: 100px;
+}
+.thumb img:hover {
+        color: #000000;
+}
+.x-view-over {
+        background: #6a8192;
+        padding: 4px;
+}
+.x-view-selected {
+        background: #cf7d6a;
+        padding: 4px;
+}
+.x-temp-crea {
+        background: #000000;
+}
+.x-temp-modif {
+        background: #ffffff;
+}
+.thumb-wrap {
+        float: left;
+        margin: 4px;
+        margin-right: 0;
+        padding: 5px;
+}
+.avertissement {
+        font-size: 15px;
+        text-align: center;
+        color: #318D9F;
+        font-weight: bold;
+}
+#liensExt {
+        float: right;
+        margin-top: -15px;
+}
+#liensExt a {
+        margin-right: 10px;
+}
+#panneau_etat_connexion,#panneau_admin {
+        min-height: 16px;
+}
+#x-up-bandeau div div {
+        height: 100 px !important;
+        background-image: url(fond-herbes.png);
+        background-repeat: repeat-x;
+}
+#x-view-zoom-img div div {
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+}
+#x-view-mini-zoom-img div div {
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+}
+.img-curseur-depl {
+        cursor: pointer;
+}
+/*#x-view-mini-zoom-img div div img {
+        height: 150px;
+        width: 150px;
+}*/
+.x-image-gen div div {
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+}
+.x-image-info-rep div div {
+        display: table-cell;
+        text-align: center;
+        vertical-align: middle;
+}
+.x-selec-modif {
+        background: #FFCCCC !important;
+}
+.x-selec-crea {
+        background: #DEE5EE !important;
+}
+.x-selec-liaison {
+        background: #FFCCCC !important;
+}
+.x-selec-consult {
+        background: #DEE5EE !important;
+}
+.x-view-notation-bar {
+        height: 25px;
+        width: 25px;
+}
+.x-view-zoom-button-p {
+        background-color: #FFFFFF;
+        background-image: url("Fleche_gauche.gif");
+        background-repeat: no-repeat;
+        background-position: 50%;
+        border: none;
+}
+.x-view-zoom-button-s {
+        background-color: #FFFFFF;
+        background-image: url("Fleche_droite.gif");
+        background-repeat: no-repeat;
+        background-position: 50%;
+        border: none;
+}
+.img-note img {
+        height: 20px;
+        width: 20px;
+}
+.thumb-wrap span {
+        display: block;
+        overflow: hidden;
+        text-align: center;
+}
+#listeImageGrid {
+        overflow: hidden;
+}
+td.centered-list {
+        display: table-cell;
+        overflow: hidden;
+        vertical-align: middle !important;
+}
+.warning_upload {
+        font-size: 15px;
+        text-align: center;
+        background-color: #ffffcc;
+        color: #ff0033;
+        font-weight: bold;
+}
+.nom_retenu {
+        font-weight: bold;
+}
+.x-form-creation {
+        background-color: green;
+}
+.x-form-modification {
+        background-color: red;
+}
+.fenmotcles .x-window-body {
+        background-color: white !important;
+}
+.nuagetag {
+        background-color: white;
+}
+.nuagetag li {
+        float: left;
+        padding: 2px;
+}
+.motcletaille1 {
+        font-size: 10px;
+        color: #990033;
+}
+.motcletaille2 {
+        font-size: 12px;
+        color: #FF9999;
+}
+.motcletaille3 {
+        font-size: 14px;
+        color: #FF9966;
+}
+.motcletaille4 {
+        font-size: 16px;
+        color: #00FF00;
+}
+.motcletaille5 {
+        font-size: 18px;
+        color: #33FF99;
+}
+.motcletaille6 {
+        font-size: 20px;
+        color: #9999FF;
+}
+.motcletaille7 {
+        font-size: 22px;
+        color: #CCCCCC;
+}
+.motcletaille8 {
+        font-size: 24px;
+        color: #999999;
+}
+.motcletaille9 {
+        font-size: 26px;
+        color: #0000FF;
+}
+.motcletaille10 {
+        font-size: 28px;
+        color: #333333;
+}
+.saisie_invalide_invisible {
+        display: none;
+}
+.saisie_invalide {
+        display: block;
+        font-size: 12px;
+        color: #FF0000;
+        text-align: center;
+}
+#lien_carto {
+        padding-left: 2px;
+        text-align: left;
+}
+#lien_coord {
+        padding-left: 0px;
+}
+.lien_actif {
+        text-align: center;
+        cursor: pointer;
+        color: #0033CC;
+        text-decoration: underline;
+}
+.lien_decale {
+        padding-left: 10px;
+}
+.conteneur_selection_localite {
+        padding-left: 10px;
+        text-decoration: none;
+}
+#lien_selection_localite {
+        color: #0033CC;
+        text-decoration: underline;
+        padding-left: 100px;
+}
+.lien_sel {
+        border: dotted 1px black;
+}
+.x-tree-node-icon-kw {
+        background-image: url("checked.png");
+        background-position: center center;
+        background-repeat: no-repeat;
+        border: 0 none;
+        height: 18px;
+        margin: 0;
+        padding: 0;
+        vertical-align: top;
+        width: 16px;
+}
+.x-tree-node a span.x-tree-node-text-norm {
+}
+.x-tree-node a span.x-tree-node-text-kw {
+        color: #008000;
+        font-weight: bold;
+        font-size: 1.1em;
+        font-style: italic;
+}
+.x-dd-drop-unlink .x-dd-drop-icon {
+        background-image: url("delier.png");
+}
+#infos_taxon {
+        margin-top: 5px;
+        vertical-align: middle !important;
+        margin-left: auto;
+        margin-right: auto;
+        text-align: center;
+}
+.texte_info_taxon {
+        font-weight: bold;
+        font-size: 1.1em;
+        font-style: italic;
+}
+.info_image {
+        font-size: 10px;
+}
+.accepter_licence {
+        font-size: 1.5em;
+        height: 70px;
+        margin-left: 20px;
+        visibility: visible;
+}
+#loading {
+        position: absolute;
+        left: 50%;
+        top: 50%;
+        margin-top: -103px; /* moitié de la hauteur de l'image */
+        margin-left: -332px; /* moitié de la largeur de l'image */
+}
+#loading img {
+        border: 2px solid black;
+}
+.indicateur_filtres {
+        color: #000000;
+        font-weight: bold !important;
+}
+.affichage_filtre {
+        padding: 3px;
+        padding-right: 1px;
+        border: solid 1px #555555;
+        background-color: #AAAAAA;
+}
+.affichage_filtre input[type="button"] {
+        background: none;
+        background-color: #999999;
+        font: 11px tahoma, arial, helvetica, sans-serif;
+}
+.liste_mots_cles {
+        list-style-position: outside;
+        margin-left: 20px;
+        list-style-type: square;
+}
+.champ-separation {
+        padding-top: 10px;
+}
+.lienAfficherChampsEtendus, .lienAjouterChampEtendu {
+        color: #0000CC;
+    cursor: pointer;
+    padding-left: 105px;
+    text-align: left;
+    text-decoration: underline;
+}
+.lienAfficherChampsEtendus {
+        padding-bottom: 10px;
+}
+.lienAjouterChampEtendu {
+    padding-bottom: 2px;
+}
+.aideCreerChampEtendu {
+    color: #666666;
+    font-size: 0.85em;
+    padding-bottom: 4px;
+    padding-top: 10px;
+    text-align: justify;
+    width: 360px;
+}
+.popup_champ_etendu {
+        border: 3px solid #667A6B;
+        z-index: 3000;
+}
+.popup_connexion {
+        z-index: 3000;
+}
+.aideWikiChampEtendu {
+    color: #666666;
+    font-size: 0.9em;
+    padding-top: 4px;
+    padding-bottom: 5px;
+    text-align: justify;
+    width: 500px;
+    height: 30px;
+}
+.descriptionChampEtenduTitre {
+        color: black;
+}
+.recherche_infos_zone_geo {
+}
+.recherche_infos_zone_geo_en_cours {
+        padding: 5px;
+}
+.recherche_infos_zone_geo_en_cours div {
+        font-size: 1.1em;
+        padding-left: 15px;
+}
+.recherche_infos_zone_geo_en_cours div, .recherche_infos_zone_geo_en_cours img {
+        float: left;
+}
+hr.nettoyage {
+        clear: both;
+        visibility: hidden;
+}
+.champAutoComplete {
+        margin-bottom: 4px;
+}
+.champAutoComplete .gwt-Label {
+        visibility: visible;
+        display: inline;
+        border: none;
+        padding-left: 53px;
+        padding-right: 7px;
+}
+.champAutoComplete div, .champAutoComplete div div {
+        border: none;
+}
+.champAutoComplete input {
+        border: 1px solid #b5b8c8;
+        background: #fff url(org.tela_botanica.cel2/js/ext/resources/images/default/form/text-bg.gif) repeat-x 0 0;
+        font: 12px tahoma,arial,helvetica,sans-serif;
+}
+.gwt-SuggestBoxPopup {
+        z-index: 9999;
+}
+.panneauEnLigne .gwt-Label {
+        display: inline;
+        padding-left: 5px;
+        padding-right: 7px;
+        height: 15px;
+}
+.panneauModePetiteLargeur div.gwt-Label {
+        display: block;
+        height: 15px;
+}
+.panneauModePetiteLargeur input {
+    margin-left: 53px;
+}
+.panneauEnLigne div {
+        border: none;
+}
+.selecteurGroupeEtendus select {
+        background: transparent;
+        border: none;
+        font-size: 14px;
+        height: 29px;
+        padding: 5px; /* If you add too much padding here, the options won't show in IE */
+        background: #fff url(org.tela_botanica.cel2/js/ext/resources/images/default/form/text-bg.gif) repeat-x 0 0;
+    border: 1px solid #b5b8c8;
+}
+.nomRetenu {
+        font-weight: bold;
+}
+img#icone_chargement {
+    border: medium none;
+    bottom: 40px;
+    font-size: 44px;
+    position: absolute;
+    right: 462px;
+}
+#texte_chargement {
+    border: medium none;
+    bottom: 33px;
+    font-family: times new roman;
+    font-size: 44px;
+    font-weight: bold;
+    left: 228px;
+    position: absolute;
+}
+#loading.splash_screen {
+        border: none;
+}
+#x-view-zoom-img div div img.invisible {
+        display: none;
+}
+#indication_aucune_image {
+    font-family: Times New Roman;
+    font-size: 40px;
+    padding-left: 40%;
+}
+#liste_selection_langue {
+        bottom: 2px;
+    float: right;
+    height: 20px;
+    position: relative;
+    visibility: visible;
+    width: 80px;
+}
+.aucune_image_pour {
+        text-align: center;
+        vertical-align: middle;
+        color: #777;
+        font-size: 35px;
+}
+.liste_projets_import {
+        position: relative;
+        bottom: 4px;
+}

/trunk/war/modele_import.txt
New file
0,0 → 1,0
"Espèce","Numéro nomenclatural","Nom retenu","Numéro nomenclatural nom retenu","Numéro taxonomique","Famille","Referentiel taxonomique","Commune","Identifiant Commune","Date","Lieu-dit","Station","Milieu","Notes","Latitude","Longitude","Altitude","Référentiel Géographique","Ordre","Identifiant","Mots Clés","Date Création","Date Modification","Transmis","Date Transmission","Abondance","Certitude","Phénologie","Image(s)","Nom Commun","champs baseflor","...","champs étendus, si renseignés","..."
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property

 /trunk/war/i18n/messages_fr.js
 New file
 ,0 → 1,408
+var messages_fr = {
+                "intitule-langue" : "Français",
+                "cel-utilisation" : "Utilisez ce carnet en ligne pour saisir vos observations",
+                "identifiez-vous" : "identifiez-vous",
+                "pour-transmettre-tela" : "pour les transmettre à Tela Botanica",
+                "connecte-en-tant-que" : "Connecté en tant que {0}",
+                "deconnexion" : "deconnexion",
+                "langue" : "Langue",
+                "import-erreurs" : "Attention ! Des erreurs se sont produites lors de l'import : {0}",
+                "import-obs-ajoutees" : "{0} observation(s) ajoutée(s)",
+                "import-images-ajoutees" : "{0} image(s) liée(s)",
+                "import-mots-cles-ajoutes" : "{0} mot(s)-clé(s) ajoutée(s)",
+                "import-colonnes-non-traitees" : "Colonnes non traitées : {0}",
+                "envoyer" : "Envoyer",
+                "filtres" : "Filtres",
+                "dates" : "Dates",
+                "inconnue" : "Inconnue",
+                "recherche-libre" : "Recherche libre",
+                "rechercher" : "Rechercher",
+                "afficher-images-tampon" : "Afficher uniquement les images dans le tampon",
+                "ajouter-images" : "Ajouter des images",
+                "tampon" : "Tampon",
+                "gerer-mots-cles" : "Gérer les mots clés",
+                "mots-cles" : "mots clés",
+                "mots-cles-arbre" : "Mots clés",
+                "voir-mots-cles" : "Voir les mots clés",
+                "appliquer" : "Appliquer",
+                "annuler" : "Annuler",
+                "nouveau-tag" : "Nouveau Tag",
+                "renommer" : "Renommer",
+                "supprimer" : "Supprimer",
+                "localites" : "Localités",
+                "projets" : "Projets",
+                "ajouter-projet" : "Ajouter un projet",
+                "supprimer-projet" : "Supprimer un projet",
+                "mot-cle-non-vide" : "Un mot clé ne peut pas être vide ou contenir les caractères suivants : {0}",
+                "mot-cle-existe-deja" : "Un mot clé de même nom existe déjà à cette position",
+                "confirmer-suppression-projet" : "Etes vous sur de vouloir supprimer ce projet ?",
+                "impossible-supprimer-racine" : "Impossible de supprimer la racine de l'arbre",
+                "aucune-image-taxon" : "Aucune image pour ce taxon",
+                "aucune-carte-taxon" : "Aucune carte pour ce taxon",
+                "aucune-image-liee" : "Aucune image liée",
+                "plusieurs-fichiers-images-fois" : "Plusieurs dossiers ou fichiers à la fois",
+                "un-fichier-image-fois" : "Un fichier à la fois",
+                "ajouter-images-tampon" :  "Ajouter les images sélectionnées au tampon",
+                "vider-tampon" : "Supprimer le contenu du tampon",
+                "afficher-tampon" : "Afficher le contenu du tampon",
+                "indication-utilisation-tampon" : "Permet de sélectionner et d'afficher des images présentes sur plusieurs pages",
+                "indication-supprimer-images" : "Supprimer les images sélectionnées",
+                "indication-plusieurs-fichiers-images-fois" : "Ajouter des images en les selectionnant une par une ou bien un dossier à la fois",
+                "galerie" : "Galerie",
+                "images" : "Images",
+                "avertissement-aucune-image" : "Aucune image à afficher",
+                "cliquez-plusieurs-fichiers-images-fois" : "Cliquez ici pour ajouter un dossier entier ou plusieurs fichiers",
+                "necessite-java" : "nécessite Java",
+                "cliquez-un-fichier-image-fois" : "Cliquez ici pour ajouter un fichier à la fois",
+                "indication-ajouter-images-plus-tard" : "Pour ajouter des images plus tard, cliquez sur Ajouter des images dans la barre d'outils",
+                "agrandissement" : "agrandissement",
+                "double-clic-agrandir" : "Double cliquez pour agrandir l'image",
+                "voir-fiche-eflore" : "Voir la fiche eFlore",
+                "numero" : "Numéro",
+                "date" : "Date",
+                "lieu" : "Lieu",
+                "appareil" : "Appareil",
+                "image" : "Image",
+                "note" : "Note",
+                "nom-original" : "Nom original",
+                "nom-associe" : "Nom associé",
+                "glissez-deposer-images-obs" : "Glissez les images sur la liste d'observation pour les lier",
+                "changer-utilisateur" : "Changer d'utilisateur",
+                "lier-images-selection-obs" : "Lier les images selectionnées à la sélection d'observation",
+                "lier-tampon-selection-obs" : "Lier le tampon à la sélection d'observation",
+                "supprimer-liaison" : "Supprimer la liaison",
+                "images-liees" : "Images liées",
+                "taxon" : "Taxon",
+                "observations" : "Observations",
+                "obs" : "Obs",
+                "toutes-observations" : "Toutes les observations",
+                "observations-liees" :  "Observations liées",
+                "glissez-deposer-obs-images" : "Glissez l'observation sur une image ou une selection d'images pour les lier",
+                "chargement" : "Chargement",
+                "lier-images-selectionnes" : "Lier aux images selectionnées",
+                "infos-generales" : "Infos",
+                "infos-exif" : "Exif",
+                "infos-iptc" : "Iptc",
+                "infos" : "Infos",
+                "commentaires" : "Commentaires",
+                "ok" : "ok",
+                "recherche-dans-observations" : "Rechercher dans les observations",
+                "exif-metadonnees" : "Metadonnées EXIF",
+                "iptc-metadonnees" : "metadonnées IPTC",
+                "indication-zoom-retour-vue-precedente" : "Double cliquez pour revenir à la vue précédente, utilisez la roulette ou les boutons fléchés pour faire défiler les images",
+                "mode-zoom" : "Mode zoom",
+                "choisir-utilisateur" : "Choisir un utilisateur",
+                "utilisateurs" : "Utilisateurs",
+                "en-recherche" : "Recherche",
+                "adresser-remarque-probleme" : "Adressez-nous vos remarques ou signalez-nous un problème",
+                "admin-consulter-donnees" : "Vous consultez les données de {0}",
+                "question-import-anonyme-connecte" : "Voulez vous importer vos observations déjà saisies dans votre compte une fois connecté",
+                "import-observations" : "Import d'observations",
+                "enoyer" : "envoyer",
+                "telecharger-modele" : "Télécharger le modèle de document",
+                "import-standard" : "pour import standard",
+                "import-champs-projets" : "pour le projet {0}",
+                "importer" : "Importer",
+                "exporter" : "Exporter",
+                "export-nc-ce-bf-bv" : "Export des noms communs, des champs étendus, des données Baseflor et des syntaxons Baseveg",
+                "export-etendu" : "Export étendu",
+                "etiquettes-pdf" : "Génération d'étiquettes au format PDF pour la sélection",
+                "etiquettes" : "Étiquettes",
+                "transmis" : "Transmis",
+                "glissez-observations-pour-lier" : "Glissez les observations sélectionnées sur un projet pour les lier",
+                "referentiel" : "Référentiel",
+                "nom-saisi" : "Nom saisi",
+                "nom-retenu" : "Nom retenu",
+                "famille" : "Famille",
+                "altitude-court" : "alt",
+                "abondance" : "Abondance",
+                "phenologie" : "Phénologie",
+                "ordre" : "Ordre",
+                "details-images-obs" : "Détails et observations",
+                "liste" : "Liste",
+                "question-envoi-images-identifie" : "L'envoi d'images nécéssite d'être identifié. Voulez-vous vous identifier maintenant ?",
+                "message-suppression-images-impossible" : "Impossible de supprimer : aucune image selectionnée",
+                "ajouter-mot-cle" : "Ajouter mot clé",
+                "renommer-mot-cle" : "Renommer mot clé",
+                "supprimer-mot-cle" : "Supprimer mot clé",
+                "nb-images-ajoutees-tampon" : "{0} image(s) ajoutées au tampon",
+                "contenu-tampon" : "Contenu du tampon",
+                "question-lier-images-obs-sel" : "Lier la selection d'images à l'observation selectionnée (ceci replacera les liaisons précédentes)",
+                "question-lier-obs-image-point" : "Lier la selection d'observations à l'image pointée (ceci replacera les liaisons précédentes)",
+                "question-lier-obs-images-sel" : "Lier la selection d'observations aux images selectionnées (ceci replacera les liaisons précédentes)",
+                "question-lier-obs-sel-images-sel" : "Lier la selection d'images aux observations selectionnées (ceci replacera les liaisons précédentes)",
+                "tampon-vide" : "Le tampon est vide",
+                "tampon-a-ete-vide" : "Le tampon a été vidé",
+                "aucune-obs-selectionnee" : "Aucune observation selectionnée",
+                "aucune-image-selectionnee" : "Aucune image selectionnée",
+                "question-supprimer-lien-images-obs" : "Supprimer le lien entre image(s) et observation(s)",
+                "page" : "Page",
+                "sur" : "sur",
+                "afficher" : "Afficher",
+                "elements" : "Elements",
+                "par-page" : "par page",
+                "aide" : "Aide",
+                "remarques" : "Remarques",
+                "bugs-remarques" : "Bugs, remarques",
+                "connexion" : "Connexion",
+                "mail" : "Mail",
+                "mail-vide-incorrect" : "Mail vide ou incorrect",
+                "mot-de-passe" : "Mot de passe",
+                "mot-de-passe-vide-incorrect" : "Mot de passe vide ou incorrect",
+                "identifiant-mot-de-passe-invalide" : "Identifiant ou mot de passe invalide",
+                "valider" : "Accepter",
+                "refuser" : "Refuser",
+                "acceptation-licence" : "Acceptation de la licence du carnet en ligne",
+                "lu-accepte-licence" : "J'ai lu et j'accepte la licence",
+                "tags" : "Tags",
+                "impossible-supprimer-racine" : "Impossible de supprimer la racine de l'arbre",
+                "identification" : "Identification",
+                "probleme-mise-a-jour-donnees" : "Problème lors de la mise à jour des données",
+                "serveur-a-repondu" : "the server has responded",
+                "mots-cles-appliques" : "Les mots clés suivants ont bien été appliqués",
+                "erreur-contacter-serveur" : "Impossible de contacter le serveur, veuillez vérifier la configuration du cel ou contacter un administrateur",
+                "mot-cle-supprime" : "Le mot clé a été supprimé",
+                "mot-cle-renomme" : "le mot clé a été renommé",
+                "liaison-mots-cles-effectuee" : "Liaison aux mots clés effectuée",
+                "requete-mal-formee" : "Requête mal formée",
+                "impossible-geolocaliser-obs" : "Impossible de géolocaliser cette observation",
+                "upload-simple-fichiers" : "Upload simple de fichiers",
+                "upload-multiple-fichiers" : "Upload multiple",
+                "indication-fin-upload-multiple-fermer" : "A la fin de l'envoi, veuillez fermer la fenêtre pour accéder aux images",
+                "saisie" : "Saisie",
+                "question-supprimer-observation" : "Êtes vous sur de vouloir supprimer cette observation",
+                "details" : "Détails",
+                "inconnue" : "Inconnue",
+                "erreur-nb-obs-étiquettes" : "Les étiquettes ne peuvent être générées pour plus de 300 observations d'un coup",
+                "question-supprimer-lien-image-obs" : "Supprimer le lien entre l'image {0} et l'observation {1}",
+                "question-supprimer-observations-sel" : "Êtes vous sur de vouloir les observations sélectionnées",
+                "supprimer-selectionnees" : "Supprimer les observations séléctionnées",
+                "aucune-observation-selectionnee" : "Aucune observation sélectionnée",
+                "rendre-publiques" : "rendre publiques",
+                "rendre-publiques-selectionnees" : "Rendre publiques les observations séléctionnées",
+                "rendre-privees" : "rendre privées",
+                "rendre-privees-selectionnees" : "Rendre privées les observations séléctionnées",
+                "question-rendre-publique-privee-observations-sel" : "Êtes-vous sur de vouloir {0} les observations sélectionnées",
+                "question-publication-observations-identifie" : "La publication des observations nécessite d'être identifié, voulez-vous vous identifier ? (toutes vos observations saisies seront conservées)",
+                "question-suppression-liaison-obs-mot-cle" : "Voulez vous supprimer la liaison entre l'observation et le mot clé",
+                "explication-panneau-carto" : "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",
+                "recherche-coordonnees-localite" : "Recherche des coordonnées et de la localité, veuillez patienter",
+                "deplacez-marqueur-pour-localiser" : "Déplacez ce marqueur pour localiser votre observation (localite et coordonnées)",
+                "aucune-information" : "Aucune information pour le nom donné",
+                "aucun-lieu-trouve" : "Aucun nom de lieu trouvé à cet emplacement",
+                "recherche-nom-lieu" : "Recherche du nom de lieu en cours...",
+                "prendre-un-moment" : "Cela peut prendre un moment",
+                "que-les-coordonnees" : "Si vous ne désirez que les coordonnées, vous pouvez cliquer dès maintenant sur OK",
+                "filtres" : "Filtres",
+                "recherche" : "Recherche",
+                "annee" : "Année",
+                "mois" : "Mois",
+                "jour" : "Jour",
+                "pays" : "Pays",
+                "departement" : "Departement",
+                "mois-1" : "janvier",
+                "mois-2" : "février",
+                "mois-3" : "mars",
+                "mois-4" : "avril",
+                "mois-5" : "mai",
+                "mois-6" : "juin",
+                "mois-7" : "juillet",
+                "mois-8" : "août",
+                "mois-9" : "septembre",
+                "mois-10" : "octobre",
+                "mois-11": "novembre",
+                "mois-12" : "décembre",
+                "mois-inconnu" : "Inconnu",
+                "indication-saisie-groupe-champ-etendus" : "Vous pouvez ajouter plusieurs champs à la fois correspondant à un groupe "+
+                                                                                                        "par exemple les champs des projet 'sauvages de ma rue' ou 'florilèges', etc... <br />"+
+                                                                                                        "De nouveaux groupes seront ajoutés régulièrement en fonction des champs les plus utilisés",
+                "ajouter-groupe-champ-etendus" : "Ajouter un groupe de champs",
+                "indication-saisie-nom-champ-etendu" : "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 valeurs déjà saisies pour ce champ par les autres utilisateurs.<br /> "+
+                                                                                                        "Les champs de la forme 'label (clé)' sont des champs 'standards' ayant un rôle et une description " +
+                                                                                                        "bien définie",
+                "nom-champ-etendu" : "Nom du champ",
+                "ajouter-fermer" : "Ajouter et fermer",
+                "indication-ajouter-fermer" : "Ajouter un champ étendu ou un groupe de champs et fermer la fenêtre",
+                "ajouter" : "Ajouter",
+                "fermer" : "Fermer",
+                "indication-ajouter-champ-etendu" : "Ajouter un champ étendu ou un groupe de champs",
+                "indication-fermer-champ-etendu" : "Fermer la fenêtre",
+                "erreur-nom-vide-champ-etendu" : "Le nom du champ étendu ne peut pas être vide",
+                "indication-aucune-description-champ-etendu" : "Aucune description n'existe pour ce champ",
+                "indication-aucune-description-champ-etendu-remplir" : "Vous pouvez la remplir sur cette page",
+                "description" : "Description",
+                "creer" : "Créer",
+                "modifier" : "Modifier",
+                "reinitialiser" : "Réinitialiser",
+                "valeurs-multiples" : "Valeurs multiples",
+                "localite" : "Localité",
+                "station" : "Station",
+                "lat" : "Lat",
+                "latitude" : "Latitude",
+                "lon" : "Lon",
+                "longitude" : "Longitude",
+                "alt" : "Alt. (mètres)",
+                "altitude" : "Altitude",
+                "coordonnees" : "Coordonnées",
+                "referentiel" : "Référentiel",
+                "espece" : "Espèce",
+                "abondance" : "Abondance",
+                "lieu-dit" : "Lieu-dit",
+                "milieu" : "Milieu",
+                "notes" : "Notes",
+                "identification" : "Identification",
+                "phenologie" : "Phénologie",
+                "afficher-champs-etendus" : "Afficher les champs étendus",
+                "cacher-champs-etendus" : "Cacher les champs étendus",
+                "ajouter-champ-etendu" : "Ajouter un champ étendu",
+                "indication-champ-etendu-existe-deja" : "Le champ {0} est déjà présent dans le formulaire",
+                "indication-bouton-creer-obs" : "Crée une nouvelle observation à partir des champs saisis dans le formulaire",
+                "indication-bouton-modifier-obs" : "Modifie la ou les observations sélectionnées",
+                "indication-bouton-reinitialiser-obs" : "Vide tous les champs du formulaire",
+                "indication-bouton-supprimer-obs" : "Supprime la ou les observations sélectionnées",
+                "erreur-localisation" : "Erreur de localisation",
+                "localiser-zone" : "Localiser la zone",
+                "aide-lien-localiser" : "Via une carte, obtenez les coordonnées (latitude/longitude) de votre observation, Vous pouvez entrer une nom sous la forme commune (departement) ou bien localite (pays) "+
+                                                                "avec un numéro de département sur 2 chiffres ou un code de pays à deux lettres (format iso 3166 1)",
+                "indication-formulaire-lat-lon" : "Lat / Lon sont les latitudes / longitudes, à remplir en degrés décimaux",
+                "saisie-lat-lon" : "Saisie Lat/Lon",
+                "indication-formulaire-localiser" : "Cliquez pour obtenir les coordonnées de votre observation à partir de la carte",
+                "localiser-la-carte" : "localiser sur la carte",
+                "indication-format-date" : "Date de l'observation au format jj/mm/aaaa",
+                "indication-localite-vide-invalide" : "Veuillez renseigner une localite suivie d'un numéro de département ou une localité suivie d'un code de pays à deux lettres \n Sous la forme : localite (departement) ou Localité (pays)",
+                "indication-date-invalide" : "Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa",
+                "date-invalide" : "Date invalide",
+                "question-modifier-observation" : "Êtes-vous sur de vouloir modifier l'observation sélectionnée",
+                "question-modifier-champs-observation" : "Voulez vous modifier le(s) champ(s) suivant(s) : {0} pour les observations selectionnées",
+                "indication-aucun-champ-modifie" : "Aucun champ n'a été modifié",
+                "indication-premiere-presence" : "Attention, le taxon {0} n'est pas signalé par la chorologie dans le département {1},\n "+
+                                                                                 "si vous êtes sûr de votre observation vous pouvez signaler votre découverte à la liste chorologie à l'adresse : {2}",
+                "certain" : "Certaine",
+                "douteux" : "Douteuse",
+                "a-determiner" : "À déterminer",
+                "abondance-5" : "5 : recouvrement R > 75%",
+                "abondance-4" : "4 : 50% < R < 75%",
+                "abondance-3" : "3 : 25% < R < 50%",
+                "abondance-2" : "2 : 5% < R < 25%",
+                "abondance-1" : "1 : 1% < R < 5%",
+                "abondance-+" : "+ : recouvrement R < 1%",
+                "abondance-r" : "r : rare (quelques pieds)",
+                "abondance-i" : "i : un seul individu",
+                "abondance-1-5" : "1-5 individus",
+                "abondance-5-10" : "5-10 individus",
+                "abondance-10-50" : "10-50 individus",
+                "abondance-50-100" : "50-100 individus",
+                "abondance-100-500" : "100-500 individus",
+                "abondance->500" : ">500 individus",
+                "abondance-E" : "E : exceptionnel",
+                "abondance-RR" : "RR : très rare",
+                "abondance-R" : "R : rare",
+                "abondance-AR" : "AR : assez rare",
+                "abondance-PC" : "PC : peu commun",
+                "abondance-AC" : "AC : assez commun",
+                "abondance-C" : "C : commun",
+                "abondance-CC" : "CC : très commun",
+                "phenologie-00-09": "00-09: germination, développement des bourgeons",
+                "phenologie-10-19": "10-19: développement des feuilles",
+                "phenologie-11": "11: par ex, environ 10% des feuilles épanouies",
+                "phenologie-15": "15: par ex, environ 50% des feuilles épanouies",
+                "phenologie-20-29": "20-29: formation de pousses latérales, tallage",
+                "phenologie-30-39": "30-39: développement des tiges, croissance des rosettes",
+                "phenologie-40-49": "40-49: développement des organes de propagation végétative",
+                "phenologie-50-59": "50-59: apparition de l'inflorescence, épiaison",
+                "phenologie-60-69": "60-69: floraison",
+                "phenologie-61" : "61: par ex, environ 10% des fleurs épanouies",
+                "phenologie-65" : "65: par ex, environ 50% des fleurs épanouies",
+                "phenologie-70-79": "70-79: fructification",
+                "phenologie-80-89": "80-89: maturité des fruits et des graines",
+                "phenologie-85": "85: par ex, 50% des fruits matures",
+                "phenologie-90-99": "90-99: sénescence et dormance",
+                "phenologie-91": "91: par ex, environ 10% des feuilles jaunes",
+                "phenologie-95": "95: par ex, environ 50% des feuilles jaunes",
+                "referentiel-bdtfx" : "Métropole (BDTFX)",
+                "referentiel-bdtfxr" : "Métropole (index réduit)",
+                "referentiel-bdtxa" : "Antilles Françaises (BDTXA)",
+                "referentiel-bdtre" : "Réunion (BDTRE)",
+                "referentiel-aublet" : "Guyane (AUBLET2)",
+                "referentiel-florical" : "Nouvelle-Calédonie (FLORICAL)",
+                "referentiel-apd" : "Afrique (APD)",
+                "referentiel-apdfna" : "Afrique du Nord (APD)",
+                "referentiel-apdfta" : "Afrique de l'Ouest et du Centre (APD)",
+                "referentiel-apdfsa" : "Afrique du Sud (APD)",
+                "referentiel-lbf" : "Liban (LBF)",
+                "referentiel-autre" : "Autre/Inconnu",
+                "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érer à 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 les 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/>"
+}

 /trunk/war/i18n/messages_nl.js
 New file
 ,0 → 1,394
+var messages_nl = {
+                "intitule-langue" : "Nederlands",
+                "cel-utilisation" : "Maak van deze ‘Carnet en Ligne’ (online boekje) gebruik om uw waarnemingen in te voeren",
+                "identifiez-vous" : "Identificeer u",
+                "pour-transmettre-tela" : "om naar Tela Botanica te sturen",
+                "connecte-en-tant-que" : "Verbinding maken als {0}",
+                "deconnexion" : "verbreken",
+                "langue" : "Taal",
+                "import-erreurs" : "Let op! Fouten bij het importeren: {0}",
+                "import-obs-ajoutees" : "{0} toegevoegde waarneming(en)",
+                "import-images-ajoutees" : "{0} toegevoegde afbeelding(en)",
+                "import-mots-cles-ajoutes" : "{0} toegevoegd(e) trefwoord(en)",
+                "import-colonnes-non-traitees" : "Niet-verwerkte kolommen {0}",
+                "envoyer" : "Verzenden",
+                "filtres" : "Filters",
+                "dates" : "Data",
+                "inconnue" : "Ongekend",
+                "recherche-libre" : "Vrij zoeken",
+                "rechercher" : "Zoeken",
+                "afficher-images-tampon" : "Uitsluitend afbeeldingen in de buffer weergeven",
+                "ajouter-images" : "Afbeeldingen toevoegen",
+                "tampon" : "Buffer",
+                "gerer-mots-cles" : "Trefwoorden beheren",
+                "mots-cles" : "Trefwoorden",
+                "mots-cles-arbre" : "Trefwoorden",
+                "voir-mots-cles" : "Trefwoorden weergeven",
+                "appliquer" : "Toepassen",
+                "annuler" : "Annuleren",
+                "nouveau-tag" : "Nieuwe Tag",
+                "renommer" : "Herbenoemen",
+                "supprimer" : "Wissen",
+                "localites" : "Plaatsen",
+                "projets" : "Projecten",
+                "ajouter-projet" : "Een project toevoegen",
+                "supprimer-projet" : "Een project wissen",
+                "mot-cle-non-vide" : "Een trefwoord kan niet leeg zijn, noch volgende tekens bevatten {0}",
+                "mot-cle-existe-deja" : "Op die plaats bestaat al een trefwoord met dezelfde naam",
+                "confirmer-suppression-projet" : "Bent u zeker dat u dit project wilt wissen?",
+                "impossible-supprimer-racine" : "boomwortel kan niet worden gewist",
+                "aucune-image-taxon" : "Geen afbeeldingen beschikbaar voor dit taxon",
+                "aucune-carte-taxon" : "Geen kaart beschikbaar voor dit taxon",
+                "aucune-image-liee" : "Geen gekoppelde afbeelding beschikbaar",
+                "plusieurs-fichiers-images-fois" : "Meerdere mappen of bestanden tegelijk",
+                "un-fichier-image-fois" : "Een bestand tegelijk",
+                "ajouter-images-tampon" : "Geselecteerde afbeeldingen toevoegen aan de buffer",
+                "vider-tampon" : "De inhoud van de buffer wissen",
+                "afficher-tampon" : "De inhoud van de buffer weergeven",
+                "indication-utilisation-tampon" : "Maakt het mogelijk om de afbeeldingen die over verschillende pagina’s lopen te selecteren en weer te geven",
+                "indication-supprimer-images" : "Wissen van de geselecteerde afbeeldingen",
+                "indication-plusieurs-fichiers-images-fois" : "Afbeeldingen toevoegen door ze een na een of als een map in zijn geheel te selecteren",
+                "galerie" : "Galerie",
+                "images" : "Afbeeldingen",
+                "avertissement-aucune-image" : "Geen afbeeldingen om weer te geven",
+                "cliquez-plusieurs-fichiers-images-fois" : "Klik hier om een of meerdere mappen tegelijk toe te voegen",
+                "necessite-java" : "Java vereist",
+                "cliquez-un-fichier-image-fois" : "Klik hier om één bestand tegelijk toe te voegen",
+                "indication-ajouter-images-plus-tard" : "Om later afbeeldingen toe te voegen klikt u op ‘Toevoegen afbeeldingen’ in de menubalk",
+                "agrandissement" : "vergroten",
+                "double-clic-agrandir" : "Dubbelklik om de afbeelding te vergroten",
+                "voir-fiche-eflore" : "Zie eFlore fiche",
+                "numero" : "Nummer",
+                "date" : "Datum",
+                "lieu" : "Plaats",
+                "appareil" : "Apparaat",
+                "image" : "Afbeelding",
+                "note" : "Opmerking",
+                "nom-original" : "Naam origineel",
+                "nom-associe" : "Geassocieerde naam",
+                "glissez-deposer-images-obs" : "Plaats de afbeeldingen op de lijst van waarnemingen om ze te koppelen",
+                "changer-utilisateur" : "Wijzigen van gebruiker",
+                "lier-images-selection-obs" : "Koppel de geselecteerde afbeeldingen aan de selectie waarnemingen",
+                "lier-tampon-selection-obs" : "Koppel de buffer aan de selectie waarnemingen",
+                "supprimer-liaison" : "De link wissen",
+                "images-liees" : "Gekoppelde afbeeldingen",
+                "taxon" : "Taxon",
+                "observations" : "Waarnemingen",
+                "obs" : "Waarn",
+                "toutes-observations" : "Alle waarnemingen",
+                "observations-liees" : "Gekoppelde waarnemingen",
+                "glissez-deposer-obs-images" : "Plaats de waarneming bij een afbeelding of een selectie afbeeldingen om ze onderling te koppelen",
+                "chargement" : "Wordt geladen",
+                "lier-images-selectionnes" : "Koppel de geselecteerde afbeeldingen",
+                "infos-generales" : "Informatie",
+                "infos-exif" : "Exif",
+                "infos-iptc" : "Iptc",
+                "infos" : "Info",
+                "commentaires" : "Commentaar",
+                "ok" : "oké",
+                "recherche-dans-observations" : "Zoeken in de waarnemingen",
+                "exif-metadonnees" : "Metagegevens EXIF",
+                "iptc-metadonnees" : "Metagegevens IPTC",
+                "indication-zoom-retour-vue-precedente" : "Dubbelklik om terug te keren naar de vorige afbeelding. Gebruik het muiswieltje of de pijltjestoetsen om door de afbeeldingen te scrollen",
+                "mode-zoom" : "Zoom modus",
+                "choisir-utilisateur" : "Een gebruiker kiezen",
+                "utilisateurs" : "Gebruikers",
+                "en-recherche" : "Zoeken",
+                "adresser-remarque-probleme" : "Stuur ons uw opmerkingen of meld een probleem",
+                "admin-consulter-donnees" : "U consulteert de gegevens van {0}",
+                "question-import-anonyme-connecte" : "Wenst u uw eerder ingevoerde waarnemingen in uw account in te voeren zodra u bent verbonden",
+                "import-observations" : "Importeren van waarnemingen",
+                "enoyer" : "verzenden",
+                "telecharger-modele" : "Het modeldocument downloaden",
+                "import-standard" : "voor standaardimport",
+                "import-champs-projets" : "voor project {0}",
+                "importer" : "Importeren",
+                "exporter" : "Exporteren",
+                "export-nc-ce-bf-bv" : "Exporteren van de volksnaam, uitgebreide velden, Baseflor gegevens en Baseveg syntaxa",
+                "export-etendu" : "Uitgebreide export",
+                "etiquettes-pdf" : "Genereren van etiketten in pdf-formaat voor de selectie",
+                "etiquettes" : "Etiketten",
+                "transmis" : "Verzonden",
+                "glissez-observations-pour-lier" : "Plaats de geselecteerde waarnemingen bij een project om ze onderling te koppelen",
+                "referentiel" : "Referentiekader",
+                "nom-saisi" : "Ingevoerde naam",
+                "nom-retenu" : "Weerhouden naam",
+                "famille" : "Familie",
+                "altitude-court" : "hoogte",
+                "abondance" : "Overvloed",
+                "phenologie" : "Fenologie",
+                "ordre" : "Orde",
+                "details-images-obs" : "Details en waarnemingen",
+                "liste" : "Lijst",
+                "question-envoi-images-identifie" : "Om te kunnen verzenden, moeten de afbeeldingen zijn geïdentificeerd. Wilt u ze nu identificeren?",
+                "message-suppression-images-impossible" : "Kan niet worden gewist: geen afbeeldingen geselecteerd",
+                "ajouter-mot-cle" : "Trefwoord toevoegen",
+                "renommer-mot-cle" : "Trefwoord herbenoemen",
+                "supprimer-mot-cle" : "Trefwoord wissen",
+                "nb-images-ajoutees-tampon" : "{0} afbeelding(en) toegevoegd aan de buffer",
+                "contenu-tampon" : "Inhoud van de buffer",
+                "question-lier-images-obs-sel" : "De selectie afbeeldingen koppelen aan de geselecteerde waarneming (dit plaatst de eerdere links terug)",
+                "question-lier-obs-image-point" : "De selectie waarnemingen koppelen aan de aangegeven afbeelding (dit plaatst de eerdere links terug)",
+                "question-lier-obs-images-sel" : "De selectie waarnemingen koppelen aan de geselecteerde afbeeldingen (dit plaatst de eerdere links terug)",
+                "question-lier-obs-sel-images-sel" : "De selectie afbeeldingen koppelen aan de geselecteerde waarnemingen (dit plaatst de eerdere links terug)",
+                "tampon-vide" : "De buffer is leeg",
+                "tampon-a-ete-vide" : "De buffer werd leeggemaakt",
+                "aucune-obs-selectionnee" : "Er werden geen waarnemingen geselecteerd",
+                "aucune-image-selectionnee" : "Er werden geen afbeeldingen geselecteerd",
+                "question-supprimer-lien-images-obs" : "De link tussen afbeelding(en) en waarneming(en) wissen",
+                "page" : "Pagina",
+                "sur" : "op",
+                "afficher" : "Weergeven",
+                "elements" : "Elementen",
+                "par-page" : "per pagina",
+                "aide" : "Help",
+                "remarques" : "Opmerkingen",
+                "bugs-remarques" : "Bugs, opmerkingen",
+                "connexion" : "Verbinden",
+                "mail" : "Mail",
+                "mail-vide-incorrect" : "Mail leeg of fout",
+                "mot-de-passe" : "Wachtwoord",
+                "mot-de-passe-vide-incorrect" : "Wachtwoord leeg of fout",
+                "identifiant-mot-de-passe-invalide" : "Gebruikersnaam of wachtwoord niet geldig",
+                "valider" : "Goedkeuren",
+                "refuser" : "Weigeren",
+                "acceptation-licence" : "Goedkeuren van de licentie voor het ‘Carnet en Ligne’",
+                "lu-accepte-licence" : "Ik heb de licentievoorwaarden gelezen en goedgekeurd",
+                "tags" : "Tags",
+                "impossible-supprimer-racine" : "boomwortel kan niet worden gewist",
+                "identification" : "Identificatie",
+                "probleme-mise-a-jour-donnees" : "Probleem bij het bijwerken van de gegevens",
+                "serveur-a-repondu" : "the server has responded",
+                "mots-cles-appliques" : "Volgende trefwoorden werden wel degelijk toegepast",
+                "erreur-contacter-serveur" : "Onmogelijk om verbinding met de server te maken. Gelieve de CeL configuratie te controleren of neem contact op met de beheerder",
+                "mot-cle-supprime" : "Het trefwoord werd gewist",
+                "mot-cle-renomme" : "Het trefwoord kreeg een nieuwe naam",
+                "liaison-mots-cles-effectuee" : "Link met trefwoorden uitgevoerd",
+                "requete-mal-formee" : "Het verzoek werd slecht geformuleerd",
+                "impossible-geolocaliser-obs" : "De waarneming kan niet worden geogelokaliseerd",
+                "upload-simple-fichiers" : "Eenvoudig uploaden van bestanden",
+                "upload-multiple-fichiers" : "Meervoudige upload",
+                "indication-fin-upload-multiple-fermer" : "Gelieve bij het einde van het verzenden het venster om toegang te krijgen tot de afbeeldingen te sluiten",
+                "saisie" : "Invoer",
+                "question-supprimer-observation" : "Bent u zeker dat u deze waarneming wenst te wissen",
+                "details" : "Details",
+                "inconnue" : "Ongekend",
+                "erreur-nb-obs-étiquettes" : "Er kunnen geen etiketten worden gegenereerd voor meer dan 300 waarnemingen in een keer",
+                "question-supprimer-lien-image-obs" : "De link tussen afbeelding {0} en waarneming {1} wissen",
+                "question-supprimer-observations-sel" : "Bent u zeker van de geselecteerde waarnemingen",
+                "supprimer-selectionnees" : "Wissen van de geselecteerde waarnemingen",
+                "aucune-observation-selectionnee" : "Er werden geen waarnemingen geselecteerd",
+                "rendre-publiques" : "Openbaar maken",
+                "rendre-publiques-selectionnees" : "De geselecteerde waarnemingen worden openbaar gemaakt",
+                "rendre-privees" : "Privé maken",
+                "rendre-privees-selectionnees" : "De geselecteerde waarnemingen worden privé gemaakt",
+                "question-rendre-publique-privee-observations-sel" : "Bent u zeker dat u de geselecteerde waarnemingen wenst te {0}",
+                "question-publication-observations-identifie" : "Voor het publiceren van de waarnemingen moet u worden geïdentificeerd. Wenst u zich te identificeren? (Alle ingevoerde waarnemingen worden bewaard)",
+                "question-suppression-liaison-obs-mot-cle" : "Wilt u de link tussen de waarneming en het trefwoord wissen",
+                "explication-panneau-carto" : "Verduidelijk de plaats van de waarneming en klik op OK. De coördinaten worden aangegeven in decimale graden, positief naar het noorden voor de breedtegraad en naar het oosten voor de lengtegraad",
+                "recherche-coordonnees-localite" : "Zoeken van de coördinaten en van de plaats. Even geduld a.u.b.",
+                "deplacez-marqueur-pour-localiser" : "Verplaats de cursor om uw waarneming te lokaliseren (plaats en coördinaten)",
+                "aucune-information" : "Geen informatie beschikbaar voor de opgegeven naam",
+                "aucun-lieu-trouve" : "Op die plek werd geen enkele plaatsnaam gevonden",
+                "recherche-nom-lieu" : "Plaatsnaam wordt gezocht ...",
+                "prendre-un-moment" : "Even geduld",
+                "que-les-coordonnees" : "Indien u voldoende hebt aan de coördinaten, kunt u nu al op OK klikken",
+                "filtres" : "Filters",
+                "recherche" : "Zoeken",
+                "annee" : "Jaar",
+                "mois" : "Maand",
+                "jour" : "Dag",
+                "pays" : "Land",
+                "departement" : "Departement",
+                "mois-1" : "januari",
+                "mois-2" : "februari",
+                "mois-3" : "maart",
+                "mois-4" : "april",
+                "mois-5" : "mei",
+                "mois-6" : "juni",
+                "mois-7" : "juli",
+                "mois-8" : "augustus",
+                "mois-9" : "september",
+                "mois-10" : "oktober",
+                "mois-11" : "november",
+                "mois-12" : "december",
+                "mois-inconnu" : "Niet gekend",
+                "indication-saisie-groupe-champ-etendus" : "U kunt meerdere velden tegelijk toevoegen voor één groep. Bijvoorbeeld de velden voor de projecten “wilde planten in mijn straat” of “anthologieën”, etc. <br /> Er worden geregeld nieuwe groepen aan toegevoegd volgens de meest gebruikte velden",
+                "ajouter-groupe-champ-etendus" : "Een groep velden toevoegen",
+                "indication-saisie-nom-champ-etendu" : "Voer een veldnaam in of selecteer de door de automatische aanvulfunctie voorgestelde naam.  Indien u opteert voor een bestaande naam, kunt u gebruik maken van de automatische invulfunctie uitgaande van waarden die voor dit veld eerder door andere gebruikers werden ingevoerd.<br />  Velden in de vorm van ‘label (trefwoord)’ zijn ‘standaard’velden die een rol en een “ + precies gedefinieerde” beschrijving hebben",
+                "nom-champ-etendu" : "Naam van het veld",
+                "ajouter-fermer" : "Toevoegen en sluiten",
+                "indication-ajouter-fermer" : "Toevoegen van een uitgebreid veld of van een groep velden en het venster sluiten",
+                "ajouter" : "Toevoegen",
+                "fermer" : "Sluiten",
+                "indication-ajouter-champ-etendu" : "Toevoegen van een uitgebreid veld of van een groep velden",
+                "indication-fermer-champ-etendu" : "Het venster sluiten",
+                "erreur-nom-vide-champ-etendu" : "De naam van een uitgebreid veld kan niet leeg zijn",
+                "indication-aucune-description-champ-etendu" : "Er werd geen beschrijving gevonden voor dit veld",
+                "indication-aucune-description-champ-etendu-remplir" : "U kunt het op deze pagina aanvullen",
+                "description" : "Beschrijving",
+                "creer" : "Aanmaken",
+                "modifier" : "Wijzigen",
+                "reinitialiser" : "Resetten",
+                "valeurs-multiples" : "Meerde waarden",
+                "localite" : "Plaats",
+                "station" : "Station",
+                "lat" : "Breedte",
+                "latitude" : "Breedtegraad",
+                "lon" : "Lengte",
+                "longitude" : "Lengtegraad",
+                "alt" : "Hoogte (meter)",
+                "altitude" : "Hoogte",
+                "coordonnees" : "Coördinaten",
+                "referentiel" : "Referentiekader",
+                "espece" : "Soort",
+                "abondance" : "Overvloed",
+                "lieu-dit" : "Gehucht",
+                "milieu" : "Milieu",
+                "notes" : "Opmerkingen",
+                "identification" : "Identificatie",
+                "phenologie" : "Fenologie",
+                "afficher-champs-etendus" : "De uitgebreide velden weergeven",
+                "cacher-champs-etendus" : "De uitgebreide velden verbergen",
+                "ajouter-champ-etendu" : "Een uitgebreid veld toevoegen",
+                "indication-champ-etendu-existe-deja" : "Het veld {0} bestaat reeds in het formulier",
+                "indication-bouton-creer-obs" : "Een nieuwe waarneming aanmaken vanaf de in het formulier ingevoerde velden",
+                "indication-bouton-modifier-obs" : "De geselecteerde waarneming(en) wordt/worden gewijzigd",
+                "indication-bouton-reinitialiser-obs" : "Alle velden van het formulier worden leeggemaakt",
+                "indication-bouton-supprimer-obs" : "De geselecteerde waarneming(en) wordt/worden gewist",
+                "erreur-localisation" : "Lokalisatiefout",
+                "localiser-zone" : "Lokaliseren van de zone",
+                "aide-lien-localiser" : "Via een kaart krijgt u de coördinaten (breedtegraad/lengtegraad) voor uw waarneming, U kunt een naam invoeren onder de gebruikelijke vorm (departement) of de plaats (land) met een nummer voor het departement met 2 cijfers of een landcode met twee letters (ISO 3166 1 formaat)",
+                "indication-formulaire-lat-lon" : "Breedte en Lengte staan voor breedtegraad en lengtegraad die in decimale graden moeten worden ingevoerd",
+                "saisie-lat-lon" : "Invoeren van de Breedte/Lengte",
+                "indication-formulaire-localiser" : "Klik om de coördinaten voor uw waarneming vanaf de kaart te kennen ",
+                "localiser-la-carte" : "Lokaliseren op een kaart",
+                "indication-format-date" : "Datum van de waarneming in het dd/mm/jjjj formaat",
+                "indication-localite-vide-invalide" : "Gelieve een plaats in te voeren gevolgd door een departementsnummer of een plaats gevolgd door een landcode met twee letters \n In de vorm: plaats (departement) of plaats (land)",
+                "indication-date-invalide" : "Let op: de ingevoerde datum is niet geldig. Voor de datum moet het dd/mm/jjjj formaat worden aangehouden",
+                "date-invalide" : "De datum is niet geldig",
+                "question-modifier-observation" : "Bent u zeker dat u de geselecteerde waarneming wenst te wijzigen",
+                "question-modifier-champs-observation" : "Wenst u volgende veld(en) te wijzigen: {0} voor de geselecteerde waarnemingen",
+                "indication-aucun-champ-modifie" : "Er werden geen velden gewijzigd",
+                "indication-premiere-presence" : "Let op: taxon {0} komt niet voor in de chorologie in departement {1},\n  Indien u zeker bent van uw waarneming, kunt u dit melden in de chorologische lijst op volgend adres: {2}",
+                "certain" : "Zeker",
+                "douteux" : "Twijfelachtig",
+                "a-determiner" : "Te bepalen",
+                "abondance-5" : "5: overlap R > 75%",
+                "abondance-4" : "4: 50% < R < 75%",
+                "abondance-3" : "3: 25% < R < 50%",
+                "abondance-2" : "2: 5% < R < 25%",
+                "abondance-1" : "1: 1% < R < 5%",
+                "abondance-+" : "+: overlap R < 1%",
+                "abondance-r" : "R: zeldzaam (enkele sporen)",
+                "abondance-i" : "I: een enkel individu",
+                "abondance-1-5" : "1-5 individuen",
+                "abondance-5-10" : "5-10 individuen",
+                "abondance-10-50" : "10-50 individuen",
+                "abondance-50-100" : "50-100 individuen",
+                "abondance-100-500" : "100-500 individuen",
+                "abondance->500" : ">500 individuen",
+                "abondance-E" : "E: uitzonderlijk",
+                "abondance-RR" : "RR: uitermate zeldzaam",
+                "abondance-R" : "R: zeldzaam",
+                "abondance-AR" : "AR: vrij zeldzaam",
+                "abondance-PC" : "PC: weinig frequent",
+                "abondance-AC" : "AC: vrij frequent",
+                "abondance-C" : "C: frequent",
+                "abondance-CC" : "CC: zeer frequent",
+                "phenologie-00-09" : "00-09: kieming, knopontwikkeling",
+                "phenologie-10-19" : "10-19: bladontwikkeling",
+                "phenologie-11" : "11: bv., ongeveer 10% ontloken bladeren",
+                "phenologie-15" : "15: bv., ongeveer 50% ontloken bladeren",
+                "phenologie-20-29" : "20-29: vorming van zijscheuten, uitstoeling",
+                "phenologie-30-39" : "30-39: ontwikkeling van stengels, ontwikkeling van rozetten",
+                "phenologie-40-49" : "40-49: ontwikkeling van de vegetatieve voortplantingsorganen",
+                "phenologie-50-59" : "50-59: optreden van bloeiwijze, aren",
+                "phenologie-60-69" : "60-69: bloeseming",
+                "phenologie-61" : "61: bv., ongeveer 10% ontloken bloemen",
+                "phenologie-65" : "65: bv., ongeveer 50% ontloken bloemen",
+                "phenologie-70-79" : "70-79: vruchtvorming",
+                "phenologie-80-89" : "80-89: rijpheid vruchten en granen",
+                "phenologie-85" : "85: bv., 50% van de vruchten zijn rijp",
+                "phenologie-90-99" : "90-99: senescentie en rustperiode",
+                "phenologie-91" : "91: bv., ongeveer 10% bladeren zijn geel",
+                "phenologie-95" : "95: bv., ongeveer 50% bladeren zijn geel",
+                "referentiel-bdtfx" : "Metropool (BDTFX)",
+                "referentiel-bdtfxr" : "Metropool  (verkorte index)",
+                "referentiel-bdtxa" : "Franse Antillen (BDTXA)",
+                "referentiel-bdtre" : "Réunion (BDTRE)",
+                "referentiel-isfan" : "Noord-Afrika (ISFAN)",
+                "referentiel-apd" : "West- en Centraal-Afrika (APD)",
+                "referentiel-lbf" : "Libanon (LBF)",
+                "referentiel-autre" : "Andere/Niet gekend",
+                "licence" : "\"Carnet en Ligne\" (CEL) is een dienst van Tela Botanica om u te helpen om uw waarnemingen op het terrein bij te houden zodat ze niet langer verborgen blijven in uw \"zakboekje\" ... Het invoeren van gegevens verloopt snel, veilig en precies. Met CEL kunt u ze makkelijk archiveren en sorteren. Als u ze publiceert - wat we graag zien, maar zonder enige verplichting - verschijnen ze op de verspreidingskaarten van de soorten op de Tela Botanica website. Zo kunt u uw mooiste foto’s van planten ook delen met de andere leden van het netwerk. U kunt de waarnemingen die u in CEL invoerde ook exporteren naar een Exceltabel om ze statistisch te verwerken of over te maken aan andere plantkundigen of naar andere softwaretoepassingen.<br>"
+                        + "<br>"
+                        + "Daartoe moet u zich akkoord verklaren met volgende voorwaarden:<br>"
+                        + "<br>"
+                        + "1. <b>Zich hebben geregistreerd bij het Tela Botanica netwerk</b>: registreren is gratis. Nadere informatie ter zake vindt u op volgend adres: <a href=\"http://www.tela-botanica.org/page:rejoindre_reseau\">http://www.tela-botanica.org/page:rejoindre_reseau</a><br>"
+                        + "<br>"
+                        + "2. <b>Met het publiceren van uw waarnemingen op de Tela Botanica website gaat u ermee akkoord: </b><br>"
+                        + "- <u>een intern gebruiksrecht af te staan aan Tela Botanica</u>, niet exclusief, niet in de tijd beperkt en gratis, voor alle gepubliceerde gegevens, met name het recht om ze te houden, te kopiëren, te archiveren, samen te voegen met gegevens van andere bronnen en allerhande berekeningen uit te voeren om er algemene informatie aan te onttrekken zoals statistieken.<br>"
+                        + "- <u>het recht af te staan aan Botanica om ze vrij en gratis te verspreiden</u>, zonder beperking in de tijd, op voorwaarde dat de naam van de auteur van de waarneming, evenals die van Tela Botanica worden vermeld. Wanneer een publicatie echter meer dan 100 verschillende auteurs omvat volstaat de vermelding \"Tela Botanica netwerk\"<br>"
+                        + "<br>"
+                        + "3. <b>U kunt op ieder moment de gegevens die u wilt uit de publicatie verwijderen</b>. In dat geval gelden de voorwaarden van het vorige artikel niet langer voor de gegevens die u uit de publicatie verwijderde, zonder dat u, mochten die gegevens intussen door derden zijn gebruikt, echter kunt terugkomen op de eerder afgestane rechten bij de initiële publicatie. <br>"
+                        + "<br>"
+                        + "4. <b>Wanneer u bij het publiceren van uw waarnemingen tevens foto’s</b> op de TB website publiceert, gaat u er akkoord mee dat ze ter beschikking worden gesteld van de gemeenschap  onder een <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a> licentie. Die terbeschikkingstelling onder een Creative Commons licentie geldt uitsluitend voor het kleinformaat van uw foto's op de Tela Botanica website. Ze geldt niet voor foto's in origineel formaat in hoge resolutie waarvan u de exclusieve eigendomsrechten behoudt.<br>"
+                        + "Volgens deze <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a> licentie mag iedereen de foto’s reproduceren, aanpassen, verspreiden en communiceren voor en aan het grote publiek mits inachtneming van volgende voorwaarden:<br>"
+                        + "- het vermelden van de naam van de oorspronkelijke auteur van het werk, evenals van die van Tela Botanica die ze uitgeeft,<br>"
+                        + "- indien de foto’s worden gewijzigd, vervormt of aangepast, wordt het recht op het verspreiden van het verkregen resultaat slechts overgedragen mits inachtneming van een soortgelijke overeenkomst,<br>"
+                        + "- bij elk hergebruik of bij elke verspreiding moeten de contractuele voorwaarden van de terbeschikkingstelling van het materiaal duidelijk worden vermeld,<br>"
+                        + "- mits de toestemming van de houder van de rechten kunnen al die voorwaarden worden opgeheven.<br>"
+                        + "<br>"
+                        + "5. <b>Met het publiceren van uw gegevens (foto’s een/of waarnemingen) op de Tela Botanica</b> website gaat u ermee akkoord dat de leden van het netwerk via uw e-mailadres contact met u kunnen opnemen om van gedachten te wisselen over de relevantie van uw determinering, de plaats van waarneming of de titel van uw foto’s.<br>"
+                        + "<br>"
+                        + "6. <b>Weergave van uw identiteit en van uw e-mailadres</b>. Het weergeven van uw identiteit gebeurt met de naam en de voornaam die u hebt opgegeven bij het initiële registreren in het Tela Botanica netwerk. Enkel het gedeelte voor het @-teken van uw e-mailadres wordt weergegeven om misbruik door derden te voorkomen. De aan u gerichte berichten worden u door Tela Botanica doorgestuurd via een tool die er garant voor staat dat uw adres niet kan worden gekraakt.<br>" +
+                        + "<br/>"
+                        + "<br/>"
+};

 /trunk/war/i18n/readme.txt
 New file
 ,0 → 1,26
+Ajouter une traduction :
+Pour ajouter une traduction, il y a plusieurs choses à faire :
+- créer un fichier message_*.js ou * est le code de la langue à traduire
+- remplacer chaque clé valeur par la liste des termes traduits
+- ajouter la langue dans la liste des langues disponibles dans le config.js
+Les métadonnées exif et iptc sont traduites à part car elles sont très très grosses
+pour les traduire, il faut créer un fichier traductionMetadonnees_*.js
+Enfin il faut ajouter les liens vers ces fichiers dans cel.html pour que la traduction soit prise
+en compte.
+Attention :
+- l'applet jUpload possède beaucoup de traductions et devrait se configurer automatiquement
+mais dans le cas où la langue demandée ne serait pas dispo, il est possible de créer une traduction
+pour celle ci et l'ajouter en recompilant l'applette.
+- De même le composant d'upload simple (situé dans vendors) doit être modifié à la main pour cela il faut
+ajouter la traduction dans les fichiers situé dans
+/vendors/gwt-ext-ux/UploadDialog/Ext.ux.UploadDialog.js et
+/vendors/gwt-ext-ux/UploadDialog/Ext.ux.UploadDialog.packed.js
+à la fin des fichiers. C'est compliqué et ça devrait nous inciter à utiliser un autre composant.
+la traduction des métadonnées et de l'upload simple est optionnelle car elle ne concerne que des parties
+mineures de l'application.
 Property changes:
 Added: svn:eol-style
 +native
 \ No newline at end of property

 /trunk/war/i18n/traductionMetadonnees_en.js
 New file
 ,0 → 1,1907
+var traductionMetadonnees_en = {
+"aeaperture" : "aeaperture",
+"aebautocancel" : "aebautocancel",
+"off" : "off",
+"on" : "on",
+"aebsequence" : "aebsequence",
+"aebsequenceautocancel" : "aebsequenceautocancel",
+",0,+/disabled" : ",0,+/disabled",
+",0,+/enabled" : ",0,+/enabled",
+"0,,+/disabled" : "0,,+/disabled",
+"0,,+/enabled" : "0,,+/enabled",
+"aebshotcount" : "aebshotcount",
+"aebxv" : "aebxv",
+"aeexposuretime" : "aeexposuretime",
+"aeextra" : "aeextra",
+"aeinfo" : "aeinfo",
+"aelock" : "aelock",
+"aemaxaperture" : "aemaxaperture",
+"aemaxaperture2" : "aemaxaperture2",
+"aemeteringmode" : "aemeteringmode",
+"multisegment" : "multisegment",
+"aemeteringsegments" : "aemeteringsegments",
+"aeminaperture" : "aeminaperture",
+"aeminexposuretime" : "aeminexposuretime",
+"aeprogrammode" : "aeprogrammode",
+"av,borx" : "av,borx",
+"candlelight" : "candlelight",
+"dofprogram" : "dofprogram",
+"dofprogram(pshift)" : "dofprogram(pshift)",
+"hispeedprogram" : "hispeedprogram",
+"hispeedprogram(pshift)" : "hispeedprogram(pshift)",
+"kids" : "kids",
+"landscape" : "landscape",
+"m,portav" : "m,portav",
+"mtfprogram" : "mtfprogram",
+"mtfprogram(pshift)" : "mtfprogram(pshift)",
+"museum" : "museum",
+"nightscene" : "nightscene",
+"nightsceneportrait" : "nightsceneportrait",
+"noflash" : "noflash",
+"pet" : "pet",
+"sunset" : "sunset",
+"surf&snow" : "surf&snow",
+"svorgreenmode" : "svorgreenmode",
+"text" : "text",
+"aexv" : "aexv",
+"ae_iso" : "ae_iso",
+"afadjustment" : "afadjustment",
+"afaperture" : "afaperture",
+"afareamode" : "afareamode",
+"1area" : "1area",
+"1area(highspeed)" : "1area(highspeed)",
+"3area(center)?" : "3area(center)?",
+"3area(highspeed)" : "3area(highspeed)",
+"3area(left)?" : "3area(left)?",
+"3area(right)?" : "3area(right)?",
+"5area" : "5area",
+"9area" : "9area",
+"facedetectaf" : "facedetectaf",
+"spotfocusing" : "spotfocusing",
+"spotmodeoff" : "spotmodeoff",
+"spotmodeon" : "spotmodeon",
+"afassist" : "afassist",
+"doesnotemit/fires" : "doesnotemit/fires",
+"emits/doesnotfire" : "emits/doesnotfire",
+"emits/fires" : "emits/fires",
+"onlyext.flashemits/fires" : "onlyext.flashemits/fires",
+"afassistbeam" : "afassistbeam",
+"doesnotemit" : "doesnotemit",
+"emits" : "emits",
+"onlyext.flashemits" : "onlyext.flashemits",
+"afdefocus" : "afdefocus",
+"afduringliveview" : "afduringliveview",
+"disable" : "disable",
+"enable" : "enable",
+"livemode" : "livemode",
+"quickmode" : "quickmode",
+"afinfo" : "afinfo",
+"afinfo2" : "afinfo2",
+"afinfo2version" : "afinfo2version",
+"afintegrationtime" : "afintegrationtime",
+"no" : "no",
+"yes" : "yes",
+"afmicroadjustment" : "afmicroadjustment",
+"adjustallbysameamount" : "adjustallbysameamount",
+"adjustbylens" : "adjustbylens",
+"afmode" : "afmode",
+"afonaelockbuttonswitch" : "afonaelockbuttonswitch",
+"afpoint" : "afpoint",
+"bottom" : "bottom",
+"center" : "center",
+"farleft" : "farleft",
+"farright" : "farright",
+"left" : "left",
+"lowerleft" : "lowerleft",
+"lowerright" : "lowerright",
+"midleft" : "midleft",
+"midright" : "midright",
+"none" : "none",
+"right" : "right",
+"top" : "top",
+"upperleft" : "upperleft",
+"upperright" : "upperright",
+"afpointactivationarea" : "afpointactivationarea",
+"automaticexpanded(max.13)" : "automaticexpanded(max.13)",
+"expanded(ttl.of7afpoints)" : "expanded(ttl.of7afpoints)",
+"singleafpoint" : "singleafpoint",
+"afpointareaexpansion" : "afpointareaexpansion",
+"left/rightafpoints" : "left/rightafpoints",
+"surroundingafpoints" : "surroundingafpoints",
+"afpointautoselection" : "afpointautoselection",
+"controldirect:disable/main:disable" : "controldirect:disable/main:disable",
+"controldirect:disable/main:enable" : "controldirect:disable/main:enable",
+"controldirect:enable/main:enable" : "controldirect:enable/main:enable",
+"afpointbrightness" : "afpointbrightness",
+"brighter" : "brighter",
+"normal" : "normal",
+"afpointdisplayduringfocus" : "afpointdisplayduringfocus",
+"on(whenfocusachieved)" : "on(whenfocusachieved)",
+"afpointillumination" : "afpointillumination",
+"onwithoutdimming" : "onwithoutdimming",
+"afpointmode" : "afpointmode",
+"afpointregistration" : "afpointregistration",
+"automatic" : "automatic",
+"extremeleft" : "extremeleft",
+"extremeright" : "extremeright",
+"afpointselected" : "afpointselected",
+"automatictrackingaf" : "automatictrackingaf",
+"fixedcenter" : "fixedcenter",
+"afpointselected2" : "afpointselected2",
+"afpointselection" : "afpointselection",
+"afpointselectionmethod" : "afpointselectionmethod",
+"multicontrollerdirect" : "multicontrollerdirect",
+"quickcontroldialdirect" : "quickcontroldialdirect",
+"afpointspotmetering" : "afpointspotmetering",
+"11/activeafpoint" : "11/activeafpoint",
+"11/centerafpoint" : "11/centerafpoint",
+"45/centerafpoint" : "45/centerafpoint",
+"9/activeafpoint" : "9/activeafpoint",
+"afpointsinfocus" : "afpointsinfocus",
+"all" : "all",
+"bottom,center" : "bottom,center",
+"bottomcenter" : "bottomcenter",
+"bottomleft" : "bottomleft",
+"bottomright" : "bottomright",
+"center(horizontal)" : "center(horizontal)",
+"center(vertical)" : "center(vertical)",
+"center+right" : "center+right",
+"fixedcenterormultiple" : "fixedcenterormultiple",
+"left+center" : "left+center",
+"left+right" : "left+right",
+"lowerleft,bottom" : "lowerleft,bottom",
+"lowerleft,midleft" : "lowerleft,midleft",
+"lowerright,bottom" : "lowerright,bottom",
+"lowerright,midright" : "lowerright,midright",
+"midleft,center" : "midleft,center",
+"midright,center" : "midright,center",
+"none(mf)" : "none(mf)",
+"top,center" : "top,center",
+"topcenter" : "topcenter",
+"topleft" : "topleft",
+"topright" : "topright",
+"upperleft,midleft" : "upperleft,midleft",
+"upperleft,top" : "upperleft,top",
+"upperright,midright" : "upperright,midright",
+"upperright,top" : "upperright,top",
+"afpointsselected" : "afpointsselected",
+"central9points" : "central9points",
+"afpointsunknown2" : "afpointsunknown2",
+"afpointsused" : "afpointsused",
+"afpredictor" : "afpredictor",
+"afresponse" : "afresponse",
+"aiservocontinuousshooting" : "aiservocontinuousshooting",
+"aiservoimagepriority" : "aiservoimagepriority",
+"1:af,2:drivespeed" : "1:af,2:drivespeed",
+"1:af,2:tracking" : "1:af,2:tracking",
+"1:release,2:drivespeed" : "1:release,2:drivespeed",
+"aiservotrackingmethod" : "aiservotrackingmethod",
+"continuousaftrackpriority" : "continuousaftrackpriority",
+"mainfocuspointpriority" : "mainfocuspointpriority",
+"aiservotrackingsensitivity" : "aiservotrackingsensitivity",
+"fast" : "fast",
+"mediumfast" : "mediumfast",
+"mediumslow" : "mediumslow",
+"moderatelyfast" : "moderatelyfast",
+"moderatelyslow" : "moderatelyslow",
+"slow" : "slow",
+"apeversion" : "apeversion",
+"armidentifier" : "armidentifier",
+"armversion" : "armversion",
+"atob0" : "atob0",
+"atob1" : "atob1",
+"atob2" : "atob2",
+"accessorytype" : "accessorytype",
+"actionadvised" : "actionadvised",
+"objectkill" : "objectkill",
+"objectreference" : "objectreference",
+"objectreplace" : "objectreplace",
+"ojbectappend" : "ojbectappend",
+"activearea" : "activearea",
+"low" : "low",
+"addaspectratioinfo" : "addaspectratioinfo",
+"addoriginaldecisiondata" : "addoriginaldecisiondata",
+"additionalmodelinformation" : "additionalmodelinformation",
+"address" : "address",
+"unknown" : "unknown",
+"advisory" : "advisory",
+"analogbalance" : "analogbalance",
+"annotations" : "annotations",
+"n/a" : "n/a",
+"antialiasstrength" : "antialiasstrength",
+"aperture" : "aperture",
+"aperturerange" : "aperturerange",
+"apertureringuse" : "apertureringuse",
+"permitted" : "permitted",
+"prohibited" : "prohibited",
+"aperturevalue" : "aperturevalue",
+"applicationrecordversion" : "applicationrecordversion",
+"applyshootingmeteringmode" : "applyshootingmeteringmode",
+"artist" : "artist",
+"artworkcopyrightnotice" : "artworkcopyrightnotice",
+"artworkcreator" : "artworkcreator",
+"artworkdatecreated" : "artworkdatecreated",
+"artworksource" : "artworksource",
+"artworksourceinventoryno" : "artworksourceinventoryno",
+"artworktitle" : "artworktitle",
+"asshoticcprofile" : "asshoticcprofile",
+"asshotneutral" : "asshotneutral",
+"asshotpreprofilematrix" : "asshotpreprofilematrix",
+"asshotprofilename" : "asshotprofilename",
+"asshotwhitexy" : "asshotwhitexy",
+"assignfuncbutton" : "assignfuncbutton",
+"exposurecomp./aebsetting" : "exposurecomp./aebsetting",
+"imagejumpwithmaindial" : "imagejumpwithmaindial",
+"imagequality" : "imagequality",
+"lcdbrightness" : "lcdbrightness",
+"liveviewfunctionsettings" : "liveviewfunctionsettings",
+"assistbuttonfunction" : "assistbuttonfunction",
+"av+/(afpointbyqcd)" : "av+/(afpointbyqcd)",
+"felock" : "felock",
+"selecthp(whilepressing)" : "selecthp(whilepressing)",
+"selecthomeposition" : "selecthomeposition",
+"audioduration" : "audioduration",
+"audiooutcue" : "audiooutcue",
+"audiosamplingrate" : "audiosamplingrate",
+"audiosamplingresolution" : "audiosamplingresolution",
+"audiotype" : "audiotype",
+"monoactuality" : "monoactuality",
+"monomusic" : "monomusic",
+"monoquestionandanswersession" : "monoquestionandanswersession",
+"monorawsound" : "monorawsound",
+"monoresponsetoaquestion" : "monoresponsetoaquestion",
+"monoscener" : "monoscener",
+"monovoicer" : "monovoicer",
+"monowrap" : "monowrap",
+"stereoactuality" : "stereoactuality",
+"stereomusic" : "stereomusic",
+"stereoquestionandanswersession" : "stereoquestionandanswersession",
+"stereorawsound" : "stereorawsound",
+"stereoresponsetoaquestion" : "stereoresponsetoaquestion",
+"stereoscener" : "stereoscener",
+"stereovoicer" : "stereovoicer",
+"stereowrap" : "stereowrap",
+"textonly" : "textonly",
+"author" : "author",
+"authorsposition" : "authorsposition",
+"autoaperture" : "autoaperture",
+"autobracketing" : "autobracketing",
+"autolightingoptimizer" : "autolightingoptimizer",
+"strong" : "strong",
+"autorotate" : "autorotate",
+"rotate180" : "rotate180",
+"rotate270cw" : "rotate270cw",
+"rotate90cw" : "rotate90cw",
+"auxiliarylens" : "auxiliarylens",
+"avaperturesetting" : "avaperturesetting",
+"avsettingwithoutlens" : "avsettingwithoutlens",
+"btoa0" : "btoa0",
+"btoa1" : "btoa1",
+"btoa2" : "btoa2",
+"backgroundcolorindicator" : "backgroundcolorindicator",
+"backgroundcolorvalue" : "backgroundcolorvalue",
+"badfaxlines" : "badfaxlines",
+"baseexposurecompensation" : "baseexposurecompensation",
+"baseurl" : "baseurl",
+"baselineexposure" : "baselineexposure",
+"baselinenoise" : "baselinenoise",
+"baselinesharpness" : "baselinesharpness",
+"batteryinfo" : "batteryinfo",
+"batterylevel" : "batterylevel",
+"bayergreensplit" : "bayergreensplit",
+"high" : "high",
+"bestqualityscale" : "bestqualityscale",
+"bitspercomponent" : "bitspercomponent",
+"bitsperextendedrunlength" : "bitsperextendedrunlength",
+"bitsperrunlength" : "bitsperrunlength",
+"bitspersample" : "bitspersample",
+"blacklevel" : "blacklevel",
+"blackleveldeltah" : "blackleveldeltah",
+"blackleveldeltav" : "blackleveldeltav",
+"blacklevelrepeatdim" : "blacklevelrepeatdim",
+"blackpoint" : "blackpoint",
+"bluebalance" : "bluebalance",
+"bluematrixcolumn" : "bluematrixcolumn",
+"bluetrc" : "bluetrc",
+"bodybatteryadload" : "bodybatteryadload",
+"bodybatteryadnoload" : "bodybatteryadnoload",
+"bodybatterystate" : "bodybatterystate",
+"almostempty" : "almostempty",
+"emptyormissing" : "emptyormissing",
+"full" : "full",
+"runninglow" : "runninglow",
+"bracketshotnumber" : "bracketshotnumber",
+"1of3" : "1of3",
+"1of5" : "1of5",
+"2of3" : "2of3",
+"2of5" : "2of5",
+"3of3" : "3of3",
+"3of5" : "3of5",
+"4of5" : "4of5",
+"5of5" : "5of5",
+"brightness" : "brightness",
+"brightnessvalue" : "brightnessvalue",
+"bulbduration" : "bulbduration",
+"burstmode" : "burstmode",
+"infinite" : "infinite",
+"buttonfunctioncontroloff" : "buttonfunctioncontroloff",
+"disablemain,control,multicontrol" : "disablemain,control,multicontrol",
+"normal(enable)" : "normal(enable)",
+"byline" : "byline",
+"bylinetitle" : "bylinetitle",
+"cfalayout" : "cfalayout",
+"evencolumnsoffsetdown1/2row" : "evencolumnsoffsetdown1/2row",
+"evencolumnsoffsetup1/2row" : "evencolumnsoffsetup1/2row",
+"evenrowsoffsetleft1/2column" : "evenrowsoffsetleft1/2column",
+"evenrowsoffsetright1/2column" : "evenrowsoffsetright1/2column",
+"rectangular" : "rectangular",
+"cfapattern" : "cfapattern",
+"cfapattern2" : "cfapattern2",
+"cfaplanecolor" : "cfaplanecolor",
+"cfarepeatpatterndim" : "cfarepeatpatterndim",
+"cmmflags" : "cmmflags",
+"cmykequivalent" : "cmykequivalent",
+"cpufirmwareversion" : "cpufirmwareversion",
+"calibrationdatetime" : "calibrationdatetime",
+"calibrationilluminant1" : "calibrationilluminant1",
+"cloudy" : "cloudy",
+"coolwhitefluorescent" : "coolwhitefluorescent",
+"daywhitefluorescent" : "daywhitefluorescent",
+"daylight" : "daylight",
+"daylightfluorescent" : "daylightfluorescent",
+"fineweather" : "fineweather",
+"fluorescent" : "fluorescent",
+"isostudiotungsten" : "isostudiotungsten",
+"other" : "other",
+"shade" : "shade",
+"standardlighta" : "standardlighta",
+"standardlightb" : "standardlightb",
+"standardlightc" : "standardlightc",
+"tungsten(incandescent)" : "tungsten(incandescent)",
+"warmwhitefluorescent" : "warmwhitefluorescent",
+"whitefluorescent" : "whitefluorescent",
+"calibrationilluminant2" : "calibrationilluminant2",
+"cameracalibration1" : "cameracalibration1",
+"cameracalibration2" : "cameracalibration2",
+"cameracalibrationsig" : "cameracalibrationsig",
+"cameraorientation" : "cameraorientation",
+"horizontal(normal)" : "horizontal(normal)",
+"cameraserialnumber" : "cameraserialnumber",
+"camerasettings" : "camerasettings",
+"cameratemperature" : "cameratemperature",
+"cameratype" : "cameratype",
+"aperturepriorityae" : "aperturepriorityae",
+"bulb" : "bulb",
+"manual" : "manual",
+"programae" : "programae",
+"shutterspeedpriorityae" : "shutterspeedpriorityae",
+"canonfirmwareversion" : "canonfirmwareversion",
+"redeyereduction" : "redeyereduction",
+"large" : "large",
+"medium" : "medium",
+"medium1" : "medium1",
+"medium2" : "medium2",
+"medium3" : "medium3",
+"small" : "small",
+"small1" : "small1",
+"small2" : "small2",
+"small3" : "small3",
+"captionabstract" : "captionabstract",
+"captionwriter" : "captionwriter",
+"um" : "um",
+"categories" : "categories",
+"category" : "category",
+"celllength" : "celllength",
+"cellwidth" : "cellwidth",
+"average" : "average",
+"certificate" : "certificate",
+"chartarget" : "chartarget",
+"characterset" : "characterset",
+"chromablurradius" : "chromablurradius",
+"chromaticadaptation" : "chromaticadaptation",
+"chromaticity" : "chromaticity",
+"circleofconfusion" : "circleofconfusion",
+"city" : "city",
+"classifystate" : "classifystate",
+"cleanfaxdata" : "cleanfaxdata",
+"clippath" : "clippath",
+"codedcharacterset" : "codedcharacterset",
+"colorbalance" : "colorbalance",
+"colorcalibrationmatrix" : "colorcalibrationmatrix",
+"colorcharacterization" : "colorcharacterization",
+"colorcomponents" : "colorcomponents",
+"coloreffect" : "coloreffect",
+"black&white" : "black&white",
+"cool" : "cool",
+"sepia" : "sepia",
+"warm" : "warm",
+"colorfilter" : "colorfilter",
+"blue" : "blue",
+"green" : "green",
+"red" : "red",
+"yellow" : "yellow",
+"colorhue" : "colorhue",
+"colorinfo" : "colorinfo",
+"colormap" : "colormap",
+"colormatrix1" : "colormatrix1",
+"colormatrix2" : "colormatrix2",
+"colormode" : "colormode",
+"adobergb" : "adobergb",
+"autumnleaves" : "autumnleaves",
+"b&w" : "b&w",
+"clear" : "clear",
+"deep" : "deep",
+"evening" : "evening",
+"light" : "light",
+"natural" : "natural",
+"neutral" : "neutral",
+"nightview" : "nightview",
+"nightview/portrait" : "nightview/portrait",
+"rgb" : "rgb",
+"vivid" : "vivid",
+"colorpalette" : "colorpalette",
+"colorrepresentation" : "colorrepresentation",
+"3components,framesequentialinmultipleobjects" : "3components,framesequentialinmultipleobjects",
+"3components,framesequentialinoneobject" : "3components,framesequentialinoneobject",
+"3components,linesequential" : "3components,linesequential",
+"3components,pixelsequential" : "3components,pixelsequential",
+"3components,singleframe" : "3components,singleframe",
+"3components,specialinterleaving" : "3components,specialinterleaving",
+"4components,framesequentialinmultipleobjects" : "4components,framesequentialinmultipleobjects",
+"4components,framesequentialinoneobject" : "4components,framesequentialinoneobject",
+"4components,linesequential" : "4components,linesequential",
+"4components,pixelsequential" : "4components,pixelsequential",
+"4components,singleframe" : "4components,singleframe",
+"4components,specialinterleaving" : "4components,specialinterleaving",
+"monochrome,singleframe" : "monochrome,singleframe",
+"noimage,singleframe" : "noimage,singleframe",
+"colorresponseunit" : "colorresponseunit",
+"colorsequence" : "colorsequence",
+"colorspace" : "colorspace",
+"iccprofile" : "iccprofile",
+"uncalibrated" : "uncalibrated",
+"widegamutrgb" : "widegamutrgb",
+"srgb" : "srgb",
+"colorspacedata" : "colorspacedata",
+"colortable" : "colortable",
+"colortemperature" : "colortemperature",
+"colortone" : "colortone",
+"colorantorder" : "colorantorder",
+"coloranttable" : "coloranttable",
+"colorimetricreference" : "colorimetricreference",
+"comment" : "comment",
+"comments" : "comments",
+"componentsconfiguration" : "componentsconfiguration",
+"compressedbitsperpixel" : "compressedbitsperpixel",
+"compression" : "compression",
+"jbigcolor" : "jbigcolor",
+"jpeg" : "jpeg",
+"jpeg(oldstyle)" : "jpeg(oldstyle)",
+"kodakdcrcompressed" : "kodakdcrcompressed",
+"kodakkdccompressed" : "kodakkdccompressed",
+"next" : "next",
+"nikonnefcompressed" : "nikonnefcompressed",
+"pentaxpefcompressed" : "pentaxpefcompressed",
+"sgilog" : "sgilog",
+"sgilog24" : "sgilog24",
+"sonyarwcompressed" : "sonyarwcompressed",
+"thunderscan" : "thunderscan",
+"uncompressed" : "uncompressed",
+"conditionalfec" : "conditionalfec",
+"connectionspaceilluminant" : "connectionspaceilluminant",
+"consecutivebadfaxlines" : "consecutivebadfaxlines",
+"contentlocationcode" : "contentlocationcode",
+"contentlocationname" : "contentlocationname",
+"movie" : "movie",
+"continuousshootingspeed" : "continuousshootingspeed",
+"continuousshotlimit" : "continuousshotlimit",
+"contrast" : "contrast",
+"medhigh" : "medhigh",
+"medlow" : "medlow",
+"mediumhigh" : "mediumhigh",
+"mediumlow" : "mediumlow",
+"veryhigh" : "veryhigh",
+"verylow" : "verylow",
+"contrastcurve" : "contrastcurve",
+"contributor" : "contributor",
+"conversionlens" : "conversionlens",
+"telephoto" : "telephoto",
+"wide" : "wide",
+"copyright" : "copyright",
+"copyrightnotice" : "copyrightnotice",
+"country" : "country",
+"countryprimarylocationcode" : "countryprimarylocationcode",
+"countryprimarylocationname" : "countryprimarylocationname",
+"countrycode" : "countrycode",
+"coverage" : "coverage",
+"createdate" : "createdate",
+"creationdate" : "creationdate",
+"creator" : "creator",
+"creatoraddress" : "creatoraddress",
+"creatorcity" : "creatorcity",
+"creatorcountry" : "creatorcountry",
+"creatorpostalcode" : "creatorpostalcode",
+"creatorregion" : "creatorregion",
+"creatortool" : "creatortool",
+"creatorworkemail" : "creatorworkemail",
+"creatorworktelephone" : "creatorworktelephone",
+"creatorworkurl" : "creatorworkurl",
+"credit" : "credit",
+"inches" : "inches",
+"currenticcprofile" : "currenticcprofile",
+"currentiptcdigest" : "currentiptcdigest",
+"currentpreprofilematrix" : "currentpreprofilematrix",
+"customrendered" : "customrendered",
+"custom" : "custom",
+"dngbackwardversion" : "dngbackwardversion",
+"dnglensinfo" : "dnglensinfo",
+"dngversion" : "dngversion",
+"dof" : "dof",
+"dspfirmwareversion" : "dspfirmwareversion",
+"datacompressionmethod" : "datacompressionmethod",
+"datadump" : "datadump",
+"datatype" : "datatype",
+"datecreated" : "datecreated",
+"datedisplayformat" : "datedisplayformat",
+"d/m/y" : "d/m/y",
+"m/d/y" : "m/d/y",
+"y/m/d" : "y/m/d",
+"datesent" : "datesent",
+"date&time" : "date&time",
+"datetime" : "datetime",
+"datetimecreated" : "datetimecreated",
+"datetimedigitized" : "datetimedigitized",
+"datetimeoriginal" : "datetimeoriginal",
+"daylightsavings" : "daylightsavings",
+"defaultcroporigin" : "defaultcroporigin",
+"defaultcropsize" : "defaultcropsize",
+"defaultscale" : "defaultscale",
+"deletedimagecount" : "deletedimagecount",
+"destinationcity" : "destinationcity",
+"destinationcitycode" : "destinationcitycode",
+"destinationdst" : "destinationdst",
+"deviceattributes" : "deviceattributes",
+"devicemanufacturer" : "devicemanufacturer",
+"devicemfgdesc" : "devicemfgdesc",
+"devicemodel" : "devicemodel",
+"devicemodeldesc" : "devicemodeldesc",
+"devicesettingdescription" : "devicesettingdescription",
+"dialdirectiontvav" : "dialdirectiontvav",
+"reversed" : "reversed",
+"digitalcreationdate" : "digitalcreationdate",
+"digitalcreationtime" : "digitalcreationtime",
+"digitalimageguid" : "digitalimageguid",
+"digitalsourcefiletype" : "digitalsourcefiletype",
+"digitalzoom" : "digitalzoom",
+"digitalzoomratio" : "digitalzoomratio",
+"directory" : "directory",
+"directorynumber" : "directorynumber",
+"djvuversion" : "djvuversion",
+"documenthistory" : "documenthistory",
+"documentname" : "documentname",
+"documentnotes" : "documentnotes",
+"dotrange" : "dotrange",
+"drivemode" : "drivemode",
+"burst" : "burst",
+"continuous" : "continuous",
+"continuoushigh" : "continuoushigh",
+"continuousshooting" : "continuousshooting",
+"multipleexposure" : "multipleexposure",
+"notimer" : "notimer",
+"remotecontrol" : "remotecontrol",
+"remotecontrol(3sdelay)" : "remotecontrol(3sdelay)",
+"selftimer(12s)" : "selftimer(12s)",
+"selftimer(2s)" : "selftimer(2s)",
+"selftimeroperation" : "selftimeroperation",
+"shutterbutton" : "shutterbutton",
+"singleexposure" : "singleexposure",
+"singleframe" : "singleframe",
+"singleframeshooting" : "singleframeshooting",
+"drivemode2" : "drivemode2",
+"duration" : "duration",
+"dynamicrangeexpansion" : "dynamicrangeexpansion",
+"dynamicrangeoptimizer" : "dynamicrangeoptimizer",
+"advancedauto" : "advancedauto",
+"advancedlv1" : "advancedlv1",
+"advancedlv2" : "advancedlv2",
+"advancedlv3" : "advancedlv3",
+"advancedlv4" : "advancedlv4",
+"advancedlv5" : "advancedlv5",
+"auto" : "auto",
+"pshift" : "pshift",
+"tvorav" : "tvorav",
+"evaluative" : "evaluative",
+"evstepinfo" : "evstepinfo",
+"evsteps" : "evsteps",
+"1/2evsteps" : "1/2evsteps",
+"1/3evsteps" : "1/3evsteps",
+"beach" : "beach",
+"coloraccent" : "coloraccent",
+"colorswap" : "colorswap",
+"fireworks" : "fireworks",
+"foliage" : "foliage",
+"indoor" : "indoor",
+"kids&pets" : "kids&pets",
+"night" : "night",
+"nightsnapshot" : "nightsnapshot",
+"snow" : "snow",
+"sports" : "sports",
+"supermacro" : "supermacro",
+"underwater" : "underwater",
+"editstatus" : "editstatus",
+"editorialupdate" : "editorialupdate",
+"additionallanguage" : "additionallanguage",
+"effectivelv" : "effectivelv",
+"effectivemaxaperture" : "effectivemaxaperture",
+"encodingprocess" : "encodingprocess",
+"baselinedct,huffmancoding" : "baselinedct,huffmancoding",
+"extendedsequentialdct,huffmancoding" : "extendedsequentialdct,huffmancoding",
+"extendedsequentialdct,arithmeticcoding" : "extendedsequentialdct,arithmeticcoding",
+"lossless,differentialhuffmancoding" : "lossless,differentialhuffmancoding",
+"lossless,huffmancoding" : "lossless,huffmancoding",
+"lossless,arithmeticcoding" : "lossless,arithmeticcoding",
+"lossless,differentialarithmeticcoding" : "lossless,differentialarithmeticcoding",
+"progressivedct,huffmancoding" : "progressivedct,huffmancoding",
+"progressivedct,arithmeticcoding" : "progressivedct,arithmeticcoding",
+"progressivedct,differentialhuffmancoding" : "progressivedct,differentialhuffmancoding",
+"progressivedct,differentialarithmeticcoding" : "progressivedct,differentialarithmeticcoding",
+"sequentialdct,differentialhuffmancoding" : "sequentialdct,differentialhuffmancoding",
+"sequentialdct,differentialarithmeticcoding" : "sequentialdct,differentialarithmeticcoding",
+"encryption" : "encryption",
+"endpoints" : "endpoints",
+"envelopenumber" : "envelopenumber",
+"envelopepriority" : "envelopepriority",
+"0(reserved)" : "0(reserved)",
+"1(mosturgent)" : "1(mosturgent)",
+"5(normalurgency)" : "5(normalurgency)",
+"8(leasturgent)" : "8(leasturgent)",
+"9(userdefinedpriority)" : "9(userdefinedpriority)",
+"enveloperecordversion" : "enveloperecordversion",
+"error" : "error",
+"event" : "event",
+"excursiontolerance" : "excursiontolerance",
+"allowed" : "allowed",
+"notallowed" : "notallowed",
+"exifbyteorder" : "exifbyteorder",
+"exifcamerainfo" : "exifcamerainfo",
+"exifimageheight" : "exifimageheight",
+"exifimagewidth" : "exifimagewidth",
+"exifoffset" : "exifoffset",
+"exiftoolversion" : "exiftoolversion",
+"exifunicodebyteorder" : "exifunicodebyteorder",
+"exifversion" : "exifversion",
+"exitpupilposition" : "exitpupilposition",
+"expandfilm" : "expandfilm",
+"expandfilterlens" : "expandfilterlens",
+"expandflashlamp" : "expandflashlamp",
+"expandlens" : "expandlens",
+"expandscanner" : "expandscanner",
+"expandsoftware" : "expandsoftware",
+"expirationdate" : "expirationdate",
+"expirationtime" : "expirationtime",
+"exposurebracketstepsize" : "exposurebracketstepsize",
+"exposurebracketvalue" : "exposurebracketvalue",
+"exposurecompensation" : "exposurecompensation",
+"exposuredifference" : "exposuredifference",
+"exposureindex" : "exposureindex",
+"exposurelevelincrements" : "exposurelevelincrements",
+"1stopset,1/3stopcomp." : "1stopset,1/3stopcomp.",
+"1/2stop" : "1/2stop",
+"1/2stopset,1/2stopcomp." : "1/2stopset,1/2stopcomp.",
+"1/3stop" : "1/3stop",
+"1/3stopset,1/3stopcomp." : "1/3stopset,1/3stopcomp.",
+"exposuremode" : "exposuremode",
+"aperturepriority" : "aperturepriority",
+"autobracket" : "autobracket",
+"nightscene/twilight" : "nightscene/twilight",
+"shutterpriority" : "shutterpriority",
+"exposuremodeinmanual" : "exposuremodeinmanual",
+"centerweightedaverage" : "centerweightedaverage",
+"evaluativemetering" : "evaluativemetering",
+"partialmetering" : "partialmetering",
+"specifiedmeteringmode" : "specifiedmeteringmode",
+"spotmetering" : "spotmetering",
+"exposureprogram" : "exposureprogram",
+"action(highspeed)" : "action(highspeed)",
+"creative(slowspeed)" : "creative(slowspeed)",
+"notdefined" : "notdefined",
+"portrait" : "portrait",
+"exposuretime" : "exposuretime",
+"exposuretime2" : "exposuretime2",
+"attached" : "attached",
+"notattached" : "notattached",
+"removed" : "removed",
+"externalflashbounce" : "externalflashbounce",
+"bounce" : "bounce",
+"externalflashexposurecomp" : "externalflashexposurecomp",
+"0.5" : "0.5",
+"1.0" : "1.0",
+"1.5" : "1.5",
+"2.0" : "2.0",
+"2.5" : "2.5",
+"3.0" : "3.0",
+"0.0" : "0.0",
+"n/a(manualmode)" : "n/a(manualmode)",
+"externalflashguidenumber" : "externalflashguidenumber",
+"externalflashmode" : "externalflashmode",
+"on,auto" : "on,auto",
+"on,contrastcontrolsync" : "on,contrastcontrolsync",
+"on,flashproblem" : "on,flashproblem",
+"on,highspeedsync" : "on,highspeedsync",
+"on,manual" : "on,manual",
+"on,pttlauto" : "on,pttlauto",
+"on,wireless" : "on,wireless",
+"on,wireless,highspeedsync" : "on,wireless,highspeedsync",
+"n/aoffautoaperture" : "n/aoffautoaperture",
+"extrasamples" : "extrasamples",
+"fnumber" : "fnumber",
+"fov" : "fov",
+"faxrecvparams" : "faxrecvparams",
+"faxrecvtime" : "faxrecvtime",
+"faxsubaddress" : "faxsubaddress",
+"fileformat" : "fileformat",
+"fileinfo" : "fileinfo",
+"fileinfoversion" : "fileinfoversion",
+"filemodifydate" : "filemodifydate",
+"filename" : "filename",
+"filenumber" : "filenumber",
+"filesize" : "filesize",
+"filesource" : "filesource",
+"digitalcamera" : "digitalcamera",
+"filmscanner" : "filmscanner",
+"reflectionprintscanner" : "reflectionprintscanner",
+"filetype" : "filetype",
+"fileversion" : "fileversion",
+"fillflashautoreduction" : "fillflashautoreduction",
+"fillorder" : "fillorder",
+"filmmode" : "filmmode",
+"dynamic(b&w)" : "dynamic(b&w)",
+"dynamic(color)" : "dynamic(color)",
+"nature(color)" : "nature(color)",
+"smooth(b&w)" : "smooth(b&w)",
+"smooth(color)" : "smooth(color)",
+"standard(b&w)" : "standard(b&w)",
+"standard(color)" : "standard(color)",
+"filtereffect" : "filtereffect",
+"finderdisplayduringexposure" : "finderdisplayduringexposure",
+"firmwareversion" : "firmwareversion",
+"fixtureidentifier" : "fixtureidentifier",
+"flash" : "flash",
+"auto,didnotfire" : "auto,didnotfire",
+"auto,didnotfire,redeyereduction" : "auto,didnotfire,redeyereduction",
+"auto,fired" : "auto,fired",
+"auto,fired,redeyereduction" : "auto,fired,redeyereduction",
+"auto,fired,redeyereduction,returndetected" : "auto,fired,redeyereduction,returndetected",
+"auto,fired,redeyereduction,returnnotdetected" : "auto,fired,redeyereduction,returnnotdetected",
+"auto,fired,returndetected" : "auto,fired,returndetected",
+"auto,fired,returnnotdetected" : "auto,fired,returnnotdetected",
+"didnotfire" : "didnotfire",
+"fired" : "fired",
+"fired,redeyereduction" : "fired,redeyereduction",
+"fired,redeyereduction,returndetected" : "fired,redeyereduction,returndetected",
+"fired,redeyereduction,returnnotdetected" : "fired,redeyereduction,returnnotdetected",
+"fired,returndetected" : "fired,returndetected",
+"fired,returnnotdetected" : "fired,returnnotdetected",
+"noflashfunction" : "noflashfunction",
+"off,didnotfire" : "off,didnotfire",
+"off,didnotfire,returnnotdetected" : "off,didnotfire,returnnotdetected",
+"off,noflashfunction" : "off,noflashfunction",
+"off,redeyereduction" : "off,redeyereduction",
+"on,didnotfire" : "on,didnotfire",
+"on,fired" : "on,fired",
+"on,redeyereduction" : "on,redeyereduction",
+"on,redeyereduction,returndetected" : "on,redeyereduction,returndetected",
+"on,redeyereduction,returnnotdetected" : "on,redeyereduction,returnnotdetected",
+"on,returndetected" : "on,returndetected",
+"on,returnnotdetected" : "on,returnnotdetected",
+"flashbias" : "flashbias",
+"flashcompensation" : "flashcompensation",
+"flashcontrolmode" : "flashcontrolmode",
+"flashenergy" : "flashenergy",
+"flashexposurebracketvalue" : "flashexposurebracketvalue",
+"flashexposurecomp" : "flashexposurecomp",
+"flashexposurecompset" : "flashexposurecompset",
+"flashfired" : "flashfired",
+"flashfiring" : "flashfiring",
+"doesnotfire" : "doesnotfire",
+"fires" : "fires",
+"flashfocallength" : "flashfocallength",
+"flashfunction" : "flashfunction",
+"flashinfo" : "flashinfo",
+"flashinfoversion" : "flashinfoversion",
+"flashmeteringsegments" : "flashmeteringsegments",
+"flashmode" : "flashmode",
+"external,auto" : "external,auto",
+"external,contrastcontrolsync" : "external,contrastcontrolsync",
+"external,flashproblem" : "external,flashproblem",
+"external,highspeedsync" : "external,highspeedsync",
+"external,manual" : "external,manual",
+"external,pttlauto" : "external,pttlauto",
+"external,wireless" : "external,wireless",
+"external,wireless,highspeedsync" : "external,wireless,highspeedsync",
+"fired,commandermode" : "fired,commandermode",
+"fired,external" : "fired,external",
+"fired,manual" : "fired,manual",
+"fired,ttlmode" : "fired,ttlmode",
+"internal" : "internal",
+"on,slowsync" : "on,slowsync",
+"on,slowsync,redeyereduction" : "on,slowsync,redeyereduction",
+"on,soft" : "on,soft",
+"on,trailingcurtainsync" : "on,trailingcurtainsync",
+"on,wireless(control)" : "on,wireless(control)",
+"on,wireless(master)" : "on,wireless(master)",
+"flashmodel" : "flashmodel",
+"flashoptions" : "flashoptions",
+"auto,redeyereduction" : "auto,redeyereduction",
+"slowsync" : "slowsync",
+"slowsync,redeyereduction" : "slowsync,redeyereduction",
+"trailingcurtainsync" : "trailingcurtainsync",
+"wireless(control)" : "wireless(control)",
+"wireless(master)" : "wireless(master)",
+"flashoptions2" : "flashoptions2",
+"flashoutput" : "flashoutput",
+"flashredeyemode" : "flashredeyemode",
+"noreturndetection" : "noreturndetection",
+"returndetected" : "returndetected",
+"returnnotdetected" : "returnnotdetected",
+"flashsetting" : "flashsetting",
+"flashstatus" : "flashstatus",
+"external,didnotfire" : "external,didnotfire",
+"external,fired" : "external,fired",
+"internal,didnotfire" : "internal,didnotfire",
+"internal,fired" : "internal,fired",
+"flashsyncspeedav" : "flashsyncspeedav",
+"1/200fixed" : "1/200fixed",
+"1/250fixed" : "1/250fixed",
+"1/300fixed" : "1/300fixed",
+"flashtype" : "flashtype",
+"builtinflash" : "builtinflash",
+"external" : "external",
+"flashpixversion" : "flashpixversion",
+"focallength" : "focallength",
+"focallength35efl" : "focallength35efl",
+"focallengthin35mmformat" : "focallengthin35mmformat",
+"focalplaneresolutionunit" : "focalplaneresolutionunit",
+"focalplanexresolution" : "focalplanexresolution",
+"focalplaneyresolution" : "focalplaneyresolution",
+"focusdistance" : "focusdistance",
+"focusmode" : "focusmode",
+"afc" : "afc",
+"afs" : "afs",
+"auto,continuous" : "auto,continuous",
+"auto,focusbutton" : "auto,focusbutton",
+"infinity" : "infinity",
+"panfocus" : "panfocus",
+"focusmode2" : "focusmode2",
+"focusposition" : "focusposition",
+"focusingscreen" : "focusingscreen",
+"forwardmatrix1" : "forwardmatrix1",
+"forwardmatrix2" : "forwardmatrix2",
+"framenumber" : "framenumber",
+"framerate" : "framerate",
+"framesize" : "framesize",
+"freebytecounts" : "freebytecounts",
+"freeoffsets" : "freeoffsets",
+"gifversion" : "gifversion",
+"gpsaltitude" : "gpsaltitude",
+"gpsaltituderef" : "gpsaltituderef",
+"abovesealevel" : "abovesealevel",
+"belowsealevel" : "belowsealevel",
+"gpsareainformation" : "gpsareainformation",
+"gpsdop" : "gpsdop",
+"gpsdatestamp" : "gpsdatestamp",
+"gpsdatetime" : "gpsdatetime",
+"gpsdestbearing" : "gpsdestbearing",
+"gpsdestbearingref" : "gpsdestbearingref",
+"magneticnorth" : "magneticnorth",
+"truenorth" : "truenorth",
+"gpsdestdistance" : "gpsdestdistance",
+"gpsdestdistanceref" : "gpsdestdistanceref",
+"kilometers" : "kilometers",
+"nauticalmiles" : "nauticalmiles",
+"gpsdestlatitude" : "gpsdestlatitude",
+"gpsdestlatituderef" : "gpsdestlatituderef",
+"north" : "north",
+"south" : "south",
+"gpsdestlongitude" : "gpsdestlongitude",
+"gpsdestlongituderef" : "gpsdestlongituderef",
+"east" : "east",
+"west" : "west",
+"gpsdifferential" : "gpsdifferential",
+"differentialcorrected" : "differentialcorrected",
+"nocorrection" : "nocorrection",
+"gpsimgdirection" : "gpsimgdirection",
+"gpsimgdirectionref" : "gpsimgdirectionref",
+"gpsinfo" : "gpsinfo",
+"gpslatitude" : "gpslatitude",
+"gpslatituderef" : "gpslatituderef",
+"gpslongitude" : "gpslongitude",
+"gpslongituderef" : "gpslongituderef",
+"gpsmapdatum" : "gpsmapdatum",
+"gpsmeasuremode" : "gpsmeasuremode",
+"2d" : "2d",
+"2dimensional" : "2dimensional",
+"2dimensionalmeasurement" : "2dimensionalmeasurement",
+"3d" : "3d",
+"3dimensional" : "3dimensional",
+"3dimensionalmeasurement" : "3dimensionalmeasurement",
+"gpsposition" : "gpsposition",
+"gpsprocessingmethod" : "gpsprocessingmethod",
+"gpssatellites" : "gpssatellites",
+"gpsspeed" : "gpsspeed",
+"gpsspeedref" : "gpsspeedref",
+"km/h" : "km/h",
+"knots" : "knots",
+"mph" : "mph",
+"gpsstatus" : "gpsstatus",
+"measurementactive" : "measurementactive",
+"measurementvoid" : "measurementvoid",
+"gpstimestamp" : "gpstimestamp",
+"gpstrack" : "gpstrack",
+"gpstrackref" : "gpstrackref",
+"gpsversionid" : "gpsversionid",
+"gaincontrol" : "gaincontrol",
+"highgaindown" : "highgaindown",
+"highgainup" : "highgainup",
+"lowgaindown" : "lowgaindown",
+"lowgainup" : "lowgainup",
+"gammacompensatedvalue" : "gammacompensatedvalue",
+"geotiffasciiparams" : "geotiffasciiparams",
+"geotiffdirectory" : "geotiffdirectory",
+"geotiffdoubleparams" : "geotiffdoubleparams",
+"gradation" : "gradation",
+"grayresponsecurve" : "grayresponsecurve",
+"grayresponseunit" : "grayresponseunit",
+"0.0001" : "0.0001",
+"0.001" : "0.001",
+"0.1" : "0.1",
+"1e05" : "1e05",
+"1e06" : "1e06",
+"graytrc" : "graytrc",
+"greenmatrixcolumn" : "greenmatrixcolumn",
+"greentrc" : "greentrc",
+"gripbatteryadload" : "gripbatteryadload",
+"gripbatteryadnoload" : "gripbatteryadnoload",
+"gripbatterystate" : "gripbatterystate",
+"hcusage" : "hcusage",
+"hdr" : "hdr",
+"halftonehints" : "halftonehints",
+"headline" : "headline",
+"highisonoisereduction" : "highisonoisereduction",
+"weak" : "weak",
+"weakest" : "weakest",
+"highlighttonepriority" : "highlighttonepriority",
+"history" : "history",
+"hometowncity" : "hometowncity",
+"hometowncitycode" : "hometowncitycode",
+"hometowndst" : "hometowndst",
+"hostcomputer" : "hostcomputer",
+"hue" : "hue",
+"hueadjustment" : "hueadjustment",
+"hyperfocaldistance" : "hyperfocaldistance",
+"iccprofilename" : "iccprofilename",
+"icc_profile" : "icc_profile",
+"id3size" : "id3size",
+"iptcnaa" : "iptcnaa",
+"iptcbitspersample" : "iptcbitspersample",
+"iptcimageheight" : "iptcimageheight",
+"iptcimagerotation" : "iptcimagerotation",
+"0" : "0",
+"180" : "180",
+"270" : "270",
+"90" : "90",
+"iptcimagewidth" : "iptcimagewidth",
+"iptcpicturenumber" : "iptcpicturenumber",
+"iptcpixelheight" : "iptcpixelheight",
+"iptcpixelwidth" : "iptcpixelwidth",
+"iso" : "iso",
+"isoexpansion" : "isoexpansion",
+"isofloor" : "isofloor",
+"isoinfo" : "isoinfo",
+"isoselection" : "isoselection",
+"isosetting" : "isosetting",
+"isospeedexpansion" : "isospeedexpansion",
+"isospeedincrements" : "isospeedincrements",
+"isospeedrange" : "isospeedrange",
+"it8header" : "it8header",
+"identifier" : "identifier",
+"imageadjustment" : "imageadjustment",
+"imageareaoffset" : "imageareaoffset",
+"imageauthentication" : "imageauthentication",
+"imageboundary" : "imageboundary",
+"imagecolorindicator" : "imagecolorindicator",
+"imagecolorvalue" : "imagecolorvalue",
+"imagecount" : "imagecount",
+"imagedatasize" : "imagedatasize",
+"imagedepth" : "imagedepth",
+"imagedescription" : "imagedescription",
+"imageeditcount" : "imageeditcount",
+"imageediting" : "imageediting",
+"cropped" : "cropped",
+"digitalfilter" : "digitalfilter",
+"framesynthesis?" : "framesynthesis?",
+"imageheight" : "imageheight",
+"imagehistory" : "imagehistory",
+"imageid" : "imageid",
+"imagelayer" : "imagelayer",
+"imagenumber" : "imagenumber",
+"imageoptimization" : "imageoptimization",
+"imageorientation" : "imageorientation",
+"square" : "square",
+"imagesize" : "imagesize",
+"imagesourcedata" : "imagesourcedata",
+"imagestabilization" : "imagestabilization",
+"on,mode1" : "on,mode1",
+"on,mode2" : "on,mode2",
+"imagetone" : "imagetone",
+"bright" : "bright",
+"imagetype" : "imagetype",
+"imageuniqueid" : "imageuniqueid",
+"imagewidth" : "imagewidth",
+"indexed" : "indexed",
+"infobuttonwhenshooting" : "infobuttonwhenshooting",
+"displayscamerasettings" : "displayscamerasettings",
+"displaysshootingfunctions" : "displaysshootingfunctions",
+"inknames" : "inknames",
+"inkset" : "inkset",
+"intellectualgenre" : "intellectualgenre",
+"cmy(k)devicedependent" : "cmy(k)devicedependent",
+"rgbdevicedependent" : "rgbdevicedependent",
+"intergraphmatrix" : "intergraphmatrix",
+"interlace" : "interlace",
+"internalflashmode" : "internalflashmode",
+"didnotfire,(unknown0xf4)" : "didnotfire,(unknown0xf4)",
+"didnotfire,auto" : "didnotfire,auto",
+"didnotfire,auto,redeyereduction" : "didnotfire,auto,redeyereduction",
+"didnotfire,normal" : "didnotfire,normal",
+"didnotfire,redeyereduction" : "didnotfire,redeyereduction",
+"didnotfire,slowsync" : "didnotfire,slowsync",
+"didnotfire,slowsync,redeyereduction" : "didnotfire,slowsync,redeyereduction",
+"didnotfire,trailingcurtainsync" : "didnotfire,trailingcurtainsync",
+"didnotfire,wireless(control)" : "didnotfire,wireless(control)",
+"didnotfire,wireless(master)" : "didnotfire,wireless(master)",
+"fired,auto" : "fired,auto",
+"fired,auto,redeyereduction" : "fired,auto,redeyereduction",
+"fired,slowsync" : "fired,slowsync",
+"fired,slowsync,redeyereduction" : "fired,slowsync,redeyereduction",
+"fired,trailingcurtainsync" : "fired,trailingcurtainsync",
+"fired,wireless(control)" : "fired,wireless(control)",
+"fired,wireless(master)" : "fired,wireless(master)",
+"internalflashstrength" : "internalflashstrength",
+"internalserialnumber" : "internalserialnumber",
+"interopindex" : "interopindex",
+"r03dcfoptionfile(adobergb)" : "r03dcfoptionfile(adobergb)",
+"r98dcfbasicfile(srgb)" : "r98dcfbasicfile(srgb)",
+"thmdcfthumbnailfile" : "thmdcfthumbnailfile",
+"interopoffset" : "interopoffset",
+"interopversion" : "interopversion",
+"iptclastedited" : "iptclastedited",
+"jfifversion" : "jfifversion",
+"jpegactables" : "jpegactables",
+"jpegdctables" : "jpegdctables",
+"jpeglosslesspredictors" : "jpeglosslesspredictors",
+"jpegpointtransforms" : "jpegpointtransforms",
+"jpegproc" : "jpegproc",
+"jpegqtables" : "jpegqtables",
+"jpegrestartinterval" : "jpegrestartinterval",
+"jpegtables" : "jpegtables",
+"jobid" : "jobid",
+"jpgrecordedpixels" : "jpgrecordedpixels",
+"10mp" : "10mp",
+"2mp" : "2mp",
+"6mp" : "6mp",
+"keyword" : "keyword",
+"keywords" : "keywords",
+"lc1" : "lc1",
+"lc10" : "lc10",
+"lc11" : "lc11",
+"lc12" : "lc12",
+"lc14" : "lc14",
+"lc15" : "lc15",
+"lc2" : "lc2",
+"lc3" : "lc3",
+"lc4" : "lc4",
+"lc5" : "lc5",
+"lc6" : "lc6",
+"lc7" : "lc7",
+"lcddisplayatpoweron" : "lcddisplayatpoweron",
+"display" : "display",
+"retainpoweroffstatus" : "retainpoweroffstatus",
+"lcddisplayreturntoshoot" : "lcddisplayreturntoshoot",
+"alsowith*etc." : "alsowith*etc.",
+"withshutterbuttononly" : "withshutterbuttononly",
+"lcdilluminationduringbulb" : "lcdilluminationduringbulb",
+"lcdpanels" : "lcdpanels",
+"iso/fileno." : "iso/fileno.",
+"iso/remain.shots" : "iso/remain.shots",
+"remain.shots/fileno." : "remain.shots/fileno.",
+"shotsinfolder/remain.shots" : "shotsinfolder/remain.shots",
+"language" : "language",
+"languageidentifier" : "languageidentifier",
+"leafdata" : "leafdata",
+"lens" : "lens",
+"lensafstopbutton" : "lensafstopbutton",
+"aelockwhilemetering" : "aelockwhilemetering",
+"afstop" : "afstop",
+"afmode:oneshot<>aiservo" : "afmode:oneshot<>aiservo",
+"afpoint:m>auto/auto>ctr." : "afpoint:m>auto/auto>ctr.",
+"afpoint:m>auto/auto>ctr" : "afpoint:m>auto/auto>ctr",
+"afstart" : "afstart",
+"isstart" : "isstart",
+"switchtoregisteredafpoint" : "switchtoregisteredafpoint",
+"lensdata" : "lensdata",
+"lensdataversion" : "lensdataversion",
+"lensdrivenoaf" : "lensdrivenoaf",
+"focussearchoff" : "focussearchoff",
+"focussearchon" : "focussearchon",
+"lensfstops" : "lensfstops",
+"lensid" : "lensid",
+"lensidnumber" : "lensidnumber",
+"lensinfo" : "lensinfo",
+"lenskind" : "lenskind",
+"lensserialnumber" : "lensserialnumber",
+"lenstype" : "lenstype",
+"lightreading" : "lightreading",
+"lightsource" : "lightsource",
+"lightvalue" : "lightvalue",
+"lightness" : "lightness",
+"linearresponselimit" : "linearresponselimit",
+"linearizationtable" : "linearizationtable",
+"liveviewexposuresimulation" : "liveviewexposuresimulation",
+"disable(lcdautoadjust)" : "disable(lcdautoadjust)",
+"enable(simulatesexposure)" : "enable(simulatesexposure)",
+"localizedcameramodel" : "localizedcameramodel",
+"location" : "location",
+"lockmicrophonebutton" : "lockmicrophonebutton",
+"protect(hold:recordmemo)" : "protect(hold:recordmemo)",
+"recordmemo(protect:disable)" : "recordmemo(protect:disable)",
+"longexposurenoisereduction" : "longexposurenoisereduction",
+"lookuptable" : "lookuptable",
+"mcuversion" : "mcuversion",
+"mieversion" : "mieversion",
+"mimetype" : "mimetype",
+"macromode" : "macromode",
+"telemacro" : "telemacro",
+"magnifiedview" : "magnifiedview",
+"imageplaybackonly" : "imageplaybackonly",
+"imagereviewandplayback" : "imagereviewandplayback",
+"make" : "make",
+"makeandmodel" : "makeandmodel",
+"makernote" : "makernote",
+"makernotesafety" : "makernotesafety",
+"safe" : "safe",
+"unsafe" : "unsafe",
+"makernoteversion" : "makernoteversion",
+"makernotes" : "makernotes",
+"manualfocusdistance" : "manualfocusdistance",
+"manualtv" : "manualtv",
+"tv=control/av=main" : "tv=control/av=main",
+"tv=control/av=mainw/olens" : "tv=control/av=mainw/olens",
+"tv=main/av=control" : "tv=main/av=control",
+"tv=main/av=mainw/olens" : "tv=main/av=mainw/olens",
+"manufacturedate" : "manufacturedate",
+"marked" : "marked",
+"maskedareas" : "maskedareas",
+"masterdocumentid" : "masterdocumentid",
+"matteing" : "matteing",
+"maxaperture" : "maxaperture",
+"maxapertureatmaxfocal" : "maxapertureatmaxfocal",
+"maxapertureatminfocal" : "maxapertureatminfocal",
+"maxaperturevalue" : "maxaperturevalue",
+"maxavailheight" : "maxavailheight",
+"maxavailwidth" : "maxavailwidth",
+"maxfocallength" : "maxfocallength",
+"maxsamplevalue" : "maxsamplevalue",
+"maxval" : "maxval",
+"maximumdensityrange" : "maximumdensityrange",
+"measurement" : "measurement",
+"measurementbacking" : "measurementbacking",
+"measurementflare" : "measurementflare",
+"measurementgeometry" : "measurementgeometry",
+"0/45or45/0" : "0/45or45/0",
+"0/dord/0" : "0/dord/0",
+"measurementilluminant" : "measurementilluminant",
+"measurementobserver" : "measurementobserver",
+"mediablackpoint" : "mediablackpoint",
+"mediawhitepoint" : "mediawhitepoint",
+"menubuttondisplayposition" : "menubuttondisplayposition",
+"previous" : "previous",
+"previous(topifpoweroff)" : "previous(topifpoweroff)",
+"metadatadate" : "metadatadate",
+"meteringmode" : "meteringmode",
+"multispot" : "multispot",
+"partial" : "partial",
+"spot" : "spot",
+"meteringmode2" : "meteringmode2",
+"meteringmode3" : "meteringmode3",
+"minaperture" : "minaperture",
+"minfocallength" : "minfocallength",
+"minsamplevalue" : "minsamplevalue",
+"minoltaquality" : "minoltaquality",
+"mirrorlockup" : "mirrorlockup",
+"enable:downwithset" : "enable:downwithset",
+"moddate" : "moddate",
+"model" : "model",
+"model2" : "model2",
+"modelage" : "modelage",
+"modeltiepoint" : "modeltiepoint",
+"modeltransform" : "modeltransform",
+"highest" : "highest",
+"tungsten" : "tungsten",
+"modifydate" : "modifydate",
+"multiexposure" : "multiexposure",
+"multiexposureautogain" : "multiexposureautogain",
+"multiexposuremode" : "multiexposuremode",
+"multiexposureshots" : "multiexposureshots",
+"multiexposureversion" : "multiexposureversion",
+"multiframenoisereduction" : "multiframenoisereduction",
+"multipleexposureset" : "multipleexposureset",
+"name" : "name",
+"namedcolor2" : "namedcolor2",
+"nativedigest" : "nativedigest",
+"nativedisplayinfo" : "nativedisplayinfo",
+"newsphotoversion" : "newsphotoversion",
+"nickname" : "nickname",
+"nikoncapturedata" : "nikoncapturedata",
+"nikoncaptureversion" : "nikoncaptureversion",
+"noise" : "noise",
+"noisereduction" : "noisereduction",
+"high(+1)" : "high(+1)",
+"highest(+2)" : "highest(+2)",
+"low(1)" : "low(1)",
+"lowest(2)" : "lowest(2)",
+"standard" : "standard",
+"noisereductionapplied" : "noisereductionapplied",
+"nominalmaxaperture" : "nominalmaxaperture",
+"nominalminaperture" : "nominalminaperture",
+"numindexentries" : "numindexentries",
+"numberofinks" : "numberofinks",
+"oecfcolumns" : "oecfcolumns",
+"oecfnames" : "oecfnames",
+"oecfrows" : "oecfrows",
+"oecfvalues" : "oecfvalues",
+"opiproxy" : "opiproxy",
+"objectattributereference" : "objectattributereference",
+"objectcycle" : "objectcycle",
+"bothmorningandevening" : "bothmorningandevening",
+"morning" : "morning",
+"objectname" : "objectname",
+"objectpreviewdata" : "objectpreviewdata",
+"objectpreviewfileformat" : "objectpreviewfileformat",
+"objectpreviewfileversion" : "objectpreviewfileversion",
+"objecttypereference" : "objecttypereference",
+"offsetschema" : "offsetschema",
+"oldsubfiletype" : "oldsubfiletype",
+"opticalzoommode" : "opticalzoommode",
+"extended" : "extended",
+"optoelectricconvfactor" : "optoelectricconvfactor",
+"orientation" : "orientation",
+"mirrorhorizontal" : "mirrorhorizontal",
+"mirrorhorizontalandrotate270cw" : "mirrorhorizontalandrotate270cw",
+"mirrorhorizontalandrotate90cw" : "mirrorhorizontalandrotate90cw",
+"mirrorvertical" : "mirrorvertical",
+"originalrawfiledata" : "originalrawfiledata",
+"originalrawfiledigest" : "originalrawfiledigest",
+"originalrawfilename" : "originalrawfilename",
+"originaltransmissionreference" : "originaltransmissionreference",
+"originatingprogram" : "originatingprogram",
+"otherimage" : "otherimage",
+"outputresponse" : "outputresponse",
+"owner" : "owner",
+"ownerid" : "ownerid",
+"ownername" : "ownername",
+"pdfversion" : "pdfversion",
+"pefversion" : "pefversion",
+"padding" : "padding",
+"pagename" : "pagename",
+"pagenumber" : "pagenumber",
+"panasonicexifversion" : "panasonicexifversion",
+"panasonicrawversion" : "panasonicrawversion",
+"panasonictitle" : "panasonictitle",
+"pentaximagesize" : "pentaximagesize",
+"2304x1728or2592x1944" : "2304x1728or2592x1944",
+"2560x1920or2304x1728" : "2560x1920or2304x1728",
+"2816x2212or2816x2112" : "2816x2212or2816x2112",
+"3008x2008or3040x2024" : "3008x2008or3040x2024",
+"pentaxmodelid" : "pentaxmodelid",
+"pentaxversion" : "pentaxversion",
+"peripherallighting" : "peripherallighting",
+"personinimage" : "personinimage",
+"phasedetectaf" : "phasedetectaf",
+"photometricinterpretation" : "photometricinterpretation",
+"blackiszero" : "blackiszero",
+"colorfilterarray" : "colorfilterarray",
+"pixarlogl" : "pixarlogl",
+"pixarlogluv" : "pixarlogluv",
+"rgbpalette" : "rgbpalette",
+"transparencymask" : "transparencymask",
+"whiteiszero" : "whiteiszero",
+"photoshopannotations" : "photoshopannotations",
+"picturecontrol" : "picturecontrol",
+"picturecontroladjust" : "picturecontroladjust",
+"defaultsettings" : "defaultsettings",
+"fullcontrol" : "fullcontrol",
+"quickadjust" : "quickadjust",
+"picturecontrolbase" : "picturecontrolbase",
+"picturecontrolname" : "picturecontrolname",
+"picturecontrolquickadjust" : "picturecontrolquickadjust",
+"picturecontrolversion" : "picturecontrolversion",
+"picturemode" : "picturemode",
+"aperturepriority,offautoaperture" : "aperturepriority,offautoaperture",
+"autopict(landscape)" : "autopict(landscape)",
+"autopict(macro)" : "autopict(macro)",
+"autopict(portrait)" : "autopict(portrait)",
+"autopict(sport)" : "autopict(sport)",
+"autopict(standard)" : "autopict(standard)",
+"autumn" : "autumn",
+"blurreduction" : "blurreduction",
+"bulb,offautoaperture" : "bulb,offautoaperture",
+"dofprogram(hyp)" : "dofprogram(hyp)",
+"darkpet" : "darkpet",
+"flashxsyncspeedae" : "flashxsyncspeedae",
+"food" : "food",
+"framecomposite" : "framecomposite",
+"greenmode" : "greenmode",
+"halflengthportrait" : "halflengthportrait",
+"hispeedprogram(hyp)" : "hispeedprogram(hyp)",
+"lightpet" : "lightpet",
+"mtfprogram(hyp)" : "mtfprogram(hyp)",
+"manual,offautoaperture" : "manual,offautoaperture",
+"mediumpet" : "mediumpet",
+"naturalskintone" : "naturalskintone",
+"program" : "program",
+"program(hyp)" : "program(hyp)",
+"programavshift" : "programavshift",
+"programtvshift" : "programtvshift",
+"selfportrait" : "selfportrait",
+"sensitivitypriorityae" : "sensitivitypriorityae",
+"shutter&aperturepriorityae" : "shutter&aperturepriorityae",
+"shutterspeedpriority" : "shutterspeedpriority",
+"soft" : "soft",
+"synchrosoundrecord" : "synchrosoundrecord",
+"picturemode2" : "picturemode2",
+"autopict" : "autopict",
+"scenemode" : "scenemode",
+"picturestyle" : "picturestyle",
+"faithful" : "faithful",
+"highsaturation" : "highsaturation",
+"lowsaturation" : "lowsaturation",
+"pixelintensityrange" : "pixelintensityrange",
+"pixelscale" : "pixelscale",
+"planarconfiguration" : "planarconfiguration",
+"chunky" : "chunky",
+"planar" : "planar",
+"postalcode" : "postalcode",
+"powersource" : "powersource",
+"bodybattery" : "bodybattery",
+"externalpowersupply" : "externalpowersupply",
+"gripbattery" : "gripbattery",
+"predictor" : "predictor",
+"horizontaldifferencing" : "horizontaldifferencing",
+"preview0" : "preview0",
+"preview1" : "preview1",
+"preview2" : "preview2",
+"previewapplicationname" : "previewapplicationname",
+"previewapplicationversion" : "previewapplicationversion",
+"previewcolorspace" : "previewcolorspace",
+"previewdatetime" : "previewdatetime",
+"previewimage" : "previewimage",
+"previewimageborders" : "previewimageborders",
+"previewimagedata" : "previewimagedata",
+"previewimagelength" : "previewimagelength",
+"previewimagesize" : "previewimagesize",
+"previewimagestart" : "previewimagestart",
+"previewsettingsdigest" : "previewsettingsdigest",
+"previewsettingsname" : "previewsettingsname",
+"c6(center)" : "c6(center)",
+"primarychromaticities" : "primarychromaticities",
+"primaryplatform" : "primaryplatform",
+"processingsoftware" : "processingsoftware",
+"producer" : "producer",
+"productid" : "productid",
+"productioncode" : "productioncode",
+"profilecmmtype" : "profilecmmtype",
+"profilecalibrationsig" : "profilecalibrationsig",
+"profileclass" : "profileclass",
+"abstractprofile" : "abstractprofile",
+"colorspaceconversionprofile" : "colorspaceconversionprofile",
+"devicelinkprofile" : "devicelinkprofile",
+"displaydeviceprofile" : "displaydeviceprofile",
+"inputdeviceprofile" : "inputdeviceprofile",
+"namedcolorprofile" : "namedcolorprofile",
+"nikoninputdeviceprofile(nonstandard!)" : "nikoninputdeviceprofile(nonstandard!)",
+"outputdeviceprofile" : "outputdeviceprofile",
+"profileconnectionspace" : "profileconnectionspace",
+"profilecopyright" : "profilecopyright",
+"profilecreator" : "profilecreator",
+"profiledatetime" : "profiledatetime",
+"profiledescription" : "profiledescription",
+"profiledescriptionml" : "profiledescriptionml",
+"profileembedpolicy" : "profileembedpolicy",
+"allowcopying" : "allowcopying",
+"embedifused" : "embedifused",
+"neverembed" : "neverembed",
+"norestrictions" : "norestrictions",
+"profilefilesignature" : "profilefilesignature",
+"profilehuesatmapdata1" : "profilehuesatmapdata1",
+"profilehuesatmapdata2" : "profilehuesatmapdata2",
+"profilehuesatmapdims" : "profilehuesatmapdims",
+"profileid" : "profileid",
+"profilelooktabledata" : "profilelooktabledata",
+"profilelooktabledims" : "profilelooktabledims",
+"profilename" : "profilename",
+"profilesequencedesc" : "profilesequencedesc",
+"profiletonecurve" : "profiletonecurve",
+"profileversion" : "profileversion",
+"programiso" : "programiso",
+"programline" : "programline",
+"depth" : "depth",
+"hispeed" : "hispeed",
+"mtf" : "mtf",
+"programshift" : "programshift",
+"programversion" : "programversion",
+"protect" : "protect",
+"provincestate" : "provincestate",
+"publisher" : "publisher",
+"quality" : "quality",
+"best" : "best",
+"better" : "better",
+"compressedraw" : "compressedraw",
+"compressedraw+jpeg" : "compressedraw+jpeg",
+"extrafine" : "extrafine",
+"good" : "good",
+"raw+jpeg" : "raw+jpeg",
+"qualitymode" : "qualitymode",
+"fine" : "fine",
+"quantizationmethod" : "quantizationmethod",
+"colorspacespecific" : "colorspacespecific",
+"compressionmethodspecific" : "compressionmethodspecific",
+"gammacompensated" : "gammacompensated",
+"iptcrefb" : "iptcrefb",
+"lineardensity" : "lineardensity",
+"lineardotpercent" : "lineardotpercent",
+"linearreflectance/transmittance" : "linearreflectance/transmittance",
+"quickcontroldialinmeter" : "quickcontroldialinmeter",
+"exposurecomp/aperture" : "exposurecomp/aperture",
+"isospeed" : "isospeed",
+"rafversion" : "rafversion",
+"rasterpadding" : "rasterpadding",
+"rasterizedcaption" : "rasterizedcaption",
+"rating" : "rating",
+"ratingpercent" : "ratingpercent",
+"rawandjpgrecording" : "rawandjpgrecording",
+"jpeg(best)" : "jpeg(best)",
+"jpeg(better)" : "jpeg(better)",
+"jpeg(good)" : "jpeg(good)",
+"raw(dng,best)" : "raw(dng,best)",
+"raw(dng,better)" : "raw(dng,better)",
+"raw(dng,good)" : "raw(dng,good)",
+"raw(pef,best)" : "raw(pef,best)",
+"raw(pef,better)" : "raw(pef,better)",
+"raw(pef,good)" : "raw(pef,good)",
+"raw+jpeg(dng,best)" : "raw+jpeg(dng,best)",
+"raw+jpeg(dng,better)" : "raw+jpeg(dng,better)",
+"raw+jpeg(dng,good)" : "raw+jpeg(dng,good)",
+"raw+jpeg(pef,best)" : "raw+jpeg(pef,best)",
+"raw+jpeg(pef,better)" : "raw+jpeg(pef,better)",
+"raw+jpeg(pef,good)" : "raw+jpeg(pef,good)",
+"raw+large/fine" : "raw+large/fine",
+"raw+large/normal" : "raw+large/normal",
+"raw+medium/fine" : "raw+medium/fine",
+"raw+medium/normal" : "raw+medium/normal",
+"raw+small/fine" : "raw+small/fine",
+"raw+small/normal" : "raw+small/normal",
+"rawdataoffset" : "rawdataoffset",
+"rawdatauniqueid" : "rawdatauniqueid",
+"rawimagecenter" : "rawimagecenter",
+"rawimagedigest" : "rawimagedigest",
+"rawimagesize" : "rawimagesize",
+"recordmode" : "recordmode",
+"redbalance" : "redbalance",
+"redmatrixcolumn" : "redmatrixcolumn",
+"redtrc" : "redtrc",
+"reductionmatrix1" : "reductionmatrix1",
+"reductionmatrix2" : "reductionmatrix2",
+"referenceblackwhite" : "referenceblackwhite",
+"referencedate" : "referencedate",
+"referencenumber" : "referencenumber",
+"referenceservice" : "referenceservice",
+"relatedimagefileformat" : "relatedimagefileformat",
+"relatedimageheight" : "relatedimageheight",
+"relatedimagewidth" : "relatedimagewidth",
+"relatedsoundfile" : "relatedsoundfile",
+"releasedate" : "releasedate",
+"releasetime" : "releasetime",
+"renderingintent" : "renderingintent",
+"iccabsolutecolorimetric" : "iccabsolutecolorimetric",
+"mediarelativecolorimetric" : "mediarelativecolorimetric",
+"perceptual" : "perceptual",
+"resolution" : "resolution",
+"resolutionunit" : "resolutionunit",
+"cm" : "cm",
+"retouchhistory" : "retouchhistory",
+"revisionnumber" : "revisionnumber",
+"rights" : "rights",
+"rowinterleavefactor" : "rowinterleavefactor",
+"rowsperstrip" : "rowsperstrip",
+"smaxsamplevalue" : "smaxsamplevalue",
+"sminsamplevalue" : "sminsamplevalue",
+"spiffversion" : "spiffversion",
+"sractive" : "sractive",
+"srfocallength" : "srfocallength",
+"srhalfpresstime" : "srhalfpresstime",
+"srresult" : "srresult",
+"notstabilized" : "notstabilized",
+"svgversion" : "svgversion",
+"safetyshift" : "safetyshift",
+"enable(isospeed)" : "enable(isospeed)",
+"enable(tv/av)" : "enable(tv/av)",
+"safetyshiftinavortv" : "safetyshiftinavortv",
+"sampleformat" : "sampleformat",
+"complexint" : "complexint",
+"float" : "float",
+"signed" : "signed",
+"undefined" : "undefined",
+"unsigned" : "unsigned",
+"samplestructure" : "samplestructure",
+"compressiondependent" : "compressiondependent",
+"orthogonal422sampling" : "orthogonal422sampling",
+"orthogonalconstangsampling" : "orthogonalconstangsampling",
+"samplesperpixel" : "samplesperpixel",
+"scanningdirection" : "scanningdirection",
+"bottomtop,lr" : "bottomtop,lr",
+"bottomtop,rl" : "bottomtop,rl",
+"lr,bottomtop" : "lr,bottomtop",
+"lr,topbottom" : "lr,topbottom",
+"rl,bottomtop" : "rl,bottomtop",
+"rl,topbottom" : "rl,topbottom",
+"topbottom,lr" : "topbottom,lr",
+"topbottom,rl" : "topbottom,rl",
+"scene" : "scene",
+"sceneassist" : "sceneassist",
+"scenecapturetype" : "scenecapturetype",
+"3dsweeppanorama" : "3dsweeppanorama",
+"antimotionblur" : "antimotionblur",
+"cont.priorityae" : "cont.priorityae",
+"handheldnightshot" : "handheldnightshot",
+"nightportrait" : "nightportrait",
+"sweeppanorama" : "sweeppanorama",
+"scenetype" : "scenetype",
+"directlyphotographed" : "directlyphotographed",
+"securityclassification" : "securityclassification",
+"confidential" : "confidential",
+"restricted" : "restricted",
+"topsecret" : "topsecret",
+"unclassified" : "unclassified",
+"selectableafpoint" : "selectableafpoint",
+"11points" : "11points",
+"19points" : "19points",
+"45points" : "45points",
+"inner9points" : "inner9points",
+"outer9points" : "outer9points",
+"selftimer" : "selftimer",
+"selftimer2" : "selftimer2",
+"selftimermode" : "selftimermode",
+"sensingmethod" : "sensingmethod",
+"colorsequentialarea" : "colorsequentialarea",
+"colorsequentiallinear" : "colorsequentiallinear",
+"monochromearea" : "monochromearea",
+"monochromelinear" : "monochromelinear",
+"onechipcolorarea" : "onechipcolorarea",
+"threechipcolorarea" : "threechipcolorarea",
+"trilinear" : "trilinear",
+"twochipcolorarea" : "twochipcolorarea",
+"sensitivityadjust" : "sensitivityadjust",
+"sensitivitysteps" : "sensitivitysteps",
+"1evsteps" : "1evsteps",
+"asevsteps" : "asevsteps",
+"sensorheight" : "sensorheight",
+"sensorpixelsize" : "sensorpixelsize",
+"sensorwidth" : "sensorwidth",
+"sequencenumber" : "sequencenumber",
+"serialnumber" : "serialnumber",
+"serviceidentifier" : "serviceidentifier",
+"setbuttoncrosskeysfunc" : "setbuttoncrosskeysfunc",
+"crosskeys:afpointselect" : "crosskeys:afpointselect",
+"set:flashexposurecomp" : "set:flashexposurecomp",
+"set:parameter" : "set:parameter",
+"set:picturestyle" : "set:picturestyle",
+"set:playback" : "set:playback",
+"set:quality" : "set:quality",
+"setbuttonwhenshooting" : "setbuttonwhenshooting",
+"changeparameters" : "changeparameters",
+"default(nofunction)" : "default(nofunction)",
+"disabled" : "disabled",
+"flashexposurecompensation" : "flashexposurecompensation",
+"imageplayback" : "imageplayback",
+"lcdmonitoron/off" : "lcdmonitoron/off",
+"menudisplay" : "menudisplay",
+"normal(disabled)" : "normal(disabled)",
+"quickcontrolscreen" : "quickcontrolscreen",
+"recordfunc.+media/folder" : "recordfunc.+media/folder",
+"recordmovie(liveview)" : "recordmovie(liveview)",
+"whitebalance" : "whitebalance",
+"setfunctionwhenshooting" : "setfunctionwhenshooting",
+"changepicturestyle" : "changepicturestyle",
+"changequality" : "changequality",
+"imagereplay" : "imagereplay",
+"shadingcompensation" : "shadingcompensation",
+"shadowscale" : "shadowscale",
+"shakereduction" : "shakereduction",
+"shakereductioninfo" : "shakereductioninfo",
+"sharpness" : "sharpness",
+"hard" : "hard",
+"medhard" : "medhard",
+"medsoft" : "medsoft",
+"veryhard" : "veryhard",
+"verysoft" : "verysoft",
+"shootingmode" : "shootingmode",
+"aerialphoto" : "aerialphoto",
+"baby" : "baby",
+"coloreffects" : "coloreffects",
+"highsensitivity" : "highsensitivity",
+"highspeedcontinuousshooting" : "highspeedcontinuousshooting",
+"intelligentauto" : "intelligentauto",
+"intelligentiso" : "intelligentiso",
+"moviepreview" : "moviepreview",
+"panning" : "panning",
+"panoramaassist" : "panoramaassist",
+"party" : "party",
+"scenery" : "scenery",
+"softskin" : "softskin",
+"starrynight" : "starrynight",
+"shortdocumentid" : "shortdocumentid",
+"shortreleasetimelag" : "shortreleasetimelag",
+"shotinfoversion" : "shotinfoversion",
+"shutteraelock" : "shutteraelock",
+"aelock/af" : "aelock/af",
+"ae/af,noaelock" : "ae/af,noaelock",
+"af/aelock" : "af/aelock",
+"af/aflock" : "af/aflock",
+"af/aflock,noaelock" : "af/aflock,noaelock",
+"shutteraelbutton" : "shutteraelbutton",
+"af/aelockstop" : "af/aelockstop",
+"shutterbuttonafonbutton" : "shutterbuttonafonbutton",
+"aelock/metering+afstart" : "aelock/metering+afstart",
+"metering+afstart" : "metering+afstart",
+"metering+afstart/afstop" : "metering+afstart/afstop",
+"metering+afstart/disable" : "metering+afstart/disable",
+"meteringstart/meter+afstart" : "meteringstart/meter+afstart",
+"shuttercount" : "shuttercount",
+"shuttercurtainsync" : "shuttercurtainsync",
+"1stcurtainsync" : "1stcurtainsync",
+"2ndcurtainsync" : "2ndcurtainsync",
+"shutterreleasenocfcard" : "shutterreleasenocfcard",
+"shutterspeed" : "shutterspeed",
+"shutterspeedrange" : "shutterspeedrange",
+"shutterspeedvalue" : "shutterspeedvalue",
+"sidecarforextension" : "sidecarforextension",
+"similarityindex" : "similarityindex",
+"slaveflashmeteringsegments" : "slaveflashmeteringsegments",
+"slowshutter" : "slowshutter",
+"software" : "software",
+"spatialfrequencyresponse" : "spatialfrequencyresponse",
+"spectralsensitivity" : "spectralsensitivity",
+"spotmeterlinktoafpoint" : "spotmeterlinktoafpoint",
+"disable(usecenterafpoint)" : "disable(usecenterafpoint)",
+"enable(useactiveafpoint)" : "enable(useactiveafpoint)",
+"state" : "state",
+"stripbytecounts" : "stripbytecounts",
+"stripoffsets" : "stripoffsets",
+"sublocation" : "sublocation",
+"subseccreatedate" : "subseccreatedate",
+"subsecdatetimeoriginal" : "subsecdatetimeoriginal",
+"subsecmodifydate" : "subsecmodifydate",
+"subsectime" : "subsectime",
+"subsectimedigitized" : "subsectimedigitized",
+"subsectimeoriginal" : "subsectimeoriginal",
+"subtileblocksize" : "subtileblocksize",
+"subfiletype" : "subfiletype",
+"subject" : "subject",
+"subjectarea" : "subjectarea",
+"subjectcode" : "subjectcode",
+"subjectdistance" : "subjectdistance",
+"subjectdistancerange" : "subjectdistancerange",
+"close" : "close",
+"distant" : "distant",
+"subjectlocation" : "subjectlocation",
+"subjectreference" : "subjectreference",
+"superimposeddisplay" : "superimposeddisplay",
+"supplementalcategories" : "supplementalcategories",
+"supplementaltype" : "supplementaltype",
+"mainimage" : "mainimage",
+"reducedresolutionimage" : "reducedresolutionimage",
+"svisosetting" : "svisosetting",
+"assist" : "assist",
+"assist+af" : "assist+af",
+"onlywhilepressingassist" : "onlywhilepressingassist",
+"t4options" : "t4options",
+"t6options" : "t6options",
+"ttl_da_adown" : "ttl_da_adown",
+"ttl_da_aup" : "ttl_da_aup",
+"ttl_da_bdown" : "ttl_da_bdown",
+"ttl_da_bup" : "ttl_da_bup",
+"targetprinter" : "targetprinter",
+"technology" : "technology",
+"activematrixdisplay" : "activematrixdisplay",
+"cathoderaytubedisplay" : "cathoderaytubedisplay",
+"dyesublimationprinter" : "dyesublimationprinter",
+"electrophotographicprinter" : "electrophotographicprinter",
+"electrostaticprinter" : "electrostaticprinter",
+"flexography" : "flexography",
+"inkjetprinter" : "inkjetprinter",
+"offsetlithography" : "offsetlithography",
+"passivematrixdisplay" : "passivematrixdisplay",
+"photocd" : "photocd",
+"photoimagesetter" : "photoimagesetter",
+"photographicpaperprinter" : "photographicpaperprinter",
+"projectiontelevision" : "projectiontelevision",
+"reflectivescanner" : "reflectivescanner",
+"silkscreen" : "silkscreen",
+"thermalwaxprinter" : "thermalwaxprinter",
+"videocamera" : "videocamera",
+"videomonitor" : "videomonitor",
+"thresholding" : "thresholding",
+"thumbnailheight" : "thumbnailheight",
+"thumbnailimage" : "thumbnailimage",
+"thumbnailimagesize" : "thumbnailimagesize",
+"thumbnailwidth" : "thumbnailwidth",
+"tilebytecounts" : "tilebytecounts",
+"tiledepth" : "tiledepth",
+"tilelength" : "tilelength",
+"tileoffsets" : "tileoffsets",
+"tilewidth" : "tilewidth",
+"time" : "time",
+"timecreated" : "timecreated",
+"timesent" : "timesent",
+"timesincepoweron" : "timesincepoweron",
+"timezoneoffset" : "timezoneoffset",
+"timerlength" : "timerlength",
+"title" : "title",
+"tonecomp" : "tonecomp",
+"tonecurve" : "tonecurve",
+"tonecurves" : "tonecurves",
+"toningeffect" : "toningeffect",
+"toningsaturation" : "toningsaturation",
+"transferfunction" : "transferfunction",
+"transferrange" : "transferrange",
+"transmissionreference" : "transmissionreference",
+"transparencyindicator" : "transparencyindicator",
+"trapindicator" : "trapindicator",
+"trapped" : "trapped",
+"false" : "false",
+"true" : "true",
+"travelday" : "travelday",
+"tvexposuretimesetting" : "tvexposuretimesetting",
+"url" : "url",
+"usmlenselectronicmf" : "usmlenselectronicmf",
+"alwaysturnedoff" : "alwaysturnedoff",
+"disableafteroneshotaf" : "disableafteroneshotaf",
+"disableinafmode" : "disableinafmode",
+"enableafteroneshotaf" : "enableafteroneshotaf",
+"turnsoffafteroneshotaf" : "turnsoffafteroneshotaf",
+"turnsonafteroneshotaf" : "turnsonafteroneshotaf",
+"uniquecameramodel" : "uniquecameramodel",
+"uniquedocumentid" : "uniquedocumentid",
+"uniqueobjectname" : "uniqueobjectname",
+"urgency" : "urgency",
+"usablemeteringmodes" : "usablemeteringmodes",
+"usableshootingmodes" : "usableshootingmodes",
+"usageterms" : "usageterms",
+"usercomment" : "usercomment",
+"vrdversion" : "vrdversion",
+"vrinfo" : "vrinfo",
+"vrinfoversion" : "vrinfoversion",
+"variprogram" : "variprogram",
+"vibrationreduction" : "vibrationreduction",
+"videocardgamma" : "videocardgamma",
+"viewinfoduringexposure" : "viewinfoduringexposure",
+"viewingconddesc" : "viewingconddesc",
+"viewingcondilluminant" : "viewingcondilluminant",
+"viewingcondilluminanttype" : "viewingcondilluminanttype",
+"viewingcondsurround" : "viewingcondsurround",
+"vignettecontrol" : "vignettecontrol",
+"wbadjustab" : "wbadjustab",
+"wbadjustgm" : "wbadjustgm",
+"wbbluelevel" : "wbbluelevel",
+"wbgreenlevel" : "wbgreenlevel",
+"wbmediaimagesizesetting" : "wbmediaimagesizesetting",
+"lcdmonitor" : "lcdmonitor",
+"rearlcdpanel" : "rearlcdpanel",
+"wbredlevel" : "wbredlevel",
+"wbshiftab" : "wbshiftab",
+"wbshiftgm" : "wbshiftgm",
+"wbshiftmg" : "wbshiftmg",
+"wb_gbrglevels" : "wb_gbrglevels",
+"wb_grbglevels" : "wb_grbglevels",
+"wb_grgblevels" : "wb_grgblevels",
+"wb_rbgglevels" : "wb_rbgglevels",
+"wb_rblevels" : "wb_rblevels",
+"wb_rblevels3000k" : "wb_rblevels3000k",
+"wb_rblevels3300k" : "wb_rblevels3300k",
+"wb_rblevels3600k" : "wb_rblevels3600k",
+"wb_rblevels3900k" : "wb_rblevels3900k",
+"wb_rblevels4000k" : "wb_rblevels4000k",
+"wb_rblevels4300k" : "wb_rblevels4300k",
+"wb_rblevels4500k" : "wb_rblevels4500k",
+"wb_rblevels4800k" : "wb_rblevels4800k",
+"wb_rblevels5300k" : "wb_rblevels5300k",
+"wb_rblevels6000k" : "wb_rblevels6000k",
+"wb_rblevels6600k" : "wb_rblevels6600k",
+"wb_rblevels7500k" : "wb_rblevels7500k",
+"wb_rblevelscloudy" : "wb_rblevelscloudy",
+"wb_rblevelsshade" : "wb_rblevelsshade",
+"wb_rblevelstungsten" : "wb_rblevelstungsten",
+"wb_rgbglevels" : "wb_rgbglevels",
+"wb_rgblevels" : "wb_rgblevels",
+"wb_rgblevelscloudy" : "wb_rgblevelscloudy",
+"wb_rgblevelsdaylight" : "wb_rgblevelsdaylight",
+"wb_rgblevelsflash" : "wb_rgblevelsflash",
+"wb_rgblevelsfluorescent" : "wb_rgblevelsfluorescent",
+"wb_rgblevelsshade" : "wb_rgblevelsshade",
+"wb_rgblevelstungsten" : "wb_rgblevelstungsten",
+"wb_rggblevels" : "wb_rggblevels",
+"wb_rggblevelscloudy" : "wb_rggblevelscloudy",
+"wb_rggblevelsdaylight" : "wb_rggblevelsdaylight",
+"wb_rggblevelsflash" : "wb_rggblevelsflash",
+"wb_rggblevelsfluorescent" : "wb_rggblevelsfluorescent",
+"wb_rggblevelsfluorescentd" : "wb_rggblevelsfluorescentd",
+"wb_rggblevelsfluorescentn" : "wb_rggblevelsfluorescentn",
+"wb_rggblevelsfluorescentw" : "wb_rggblevelsfluorescentw",
+"wb_rggblevelsshade" : "wb_rggblevelsshade",
+"wb_rggblevelstungsten" : "wb_rggblevelstungsten",
+"wcsprofiles" : "wcsprofiles",
+"warning" : "warning",
+"webstatement" : "webstatement",
+"colortemperature/colorfilter" : "colortemperature/colorfilter",
+"custom1" : "custom1",
+"custom2" : "custom2",
+"custom3" : "custom3",
+"custom4" : "custom4",
+"manualtemperature(kelvin)" : "manualtemperature(kelvin)",
+"userselected" : "userselected",
+"whitebalancebias" : "whitebalancebias",
+"whitebalancefinetune" : "whitebalancefinetune",
+"whitebalancemode" : "whitebalancemode",
+"auto(cloudy)" : "auto(cloudy)",
+"auto(daywhitefluorescent)" : "auto(daywhitefluorescent)",
+"auto(daylightfluorescent)" : "auto(daylightfluorescent)",
+"auto(daylight)" : "auto(daylight)",
+"auto(flash)" : "auto(flash)",
+"auto(shade)" : "auto(shade)",
+"auto(tungsten)" : "auto(tungsten)",
+"auto(whitefluorescent)" : "auto(whitefluorescent)",
+"whitebalanceset" : "whitebalanceset",
+"setcolortemperature1" : "setcolortemperature1",
+"setcolortemperature2" : "setcolortemperature2",
+"setcolortemperature3" : "setcolortemperature3",
+"whitelevel" : "whitelevel",
+"whitepoint" : "whitepoint",
+"worldtime" : "worldtime",
+"worldtimelocation" : "worldtimelocation",
+"home" : "home",
+"hometown" : "hometown",
+"writereditor" : "writereditor",
+"xclippathunits" : "xclippathunits",
+"xmp" : "xmp",
+"xpauthor" : "xpauthor",
+"xpcomment" : "xpcomment",
+"xpkeywords" : "xpkeywords",
+"xpsubject" : "xpsubject",
+"xptitle" : "xptitle",
+"xposition" : "xposition",
+"xresolution" : "xresolution",
+"ycbcrcoefficients" : "ycbcrcoefficients",
+"ycbcrpositioning" : "ycbcrpositioning",
+"centered" : "centered",
+"cosited" : "cosited",
+"ycbcrsubsampling" : "ycbcrsubsampling",
+"yclippathunits" : "yclippathunits",
+"yposition" : "yposition",
+"yresolution" : "yresolution",
+"year" : "year",
+"zonematching" : "zonematching",
+"highkey" : "highkey",
+"isosettingused" : "isosettingused",
+"lowkey" : "lowkey",
+};

 /trunk/war/i18n/traductionMetadonnees_fr.js
 New file
 ,0 → 1,1907
+var traductionMetadonnees_fr = {
+"aeaperture" : "Ouverture AE",
+"aebautocancel" : "Annulation bracketing auto",
+"off" : "Désactivé",
+"on" : "Activé",
+"aebsequence" : "Séquence de bracketing",
+"aebsequenceautocancel" : "Séquence auto AEB/annuler",
+",0,+/disabled" : "-,0,+/Désactivé",
+",0,+/enabled" : "-,0,+/Activé",
+"0,,+/disabled" : "0,-,+/Désactivé",
+"0,,+/enabled" : "0,-,+/Activé",
+"aebshotcount" : "Nombre de vues bracketées",
+"aebxv" : "Compensation d\'expo. auto en bracketing",
+"aeexposuretime" : "Temps d\'exposition AE",
+"aeextra" : "Suppléments AE",
+"aeinfo" : "Info sur l\'exposition auto",
+"aelock" : "Verrouillage AE",
+"aemaxaperture" : "Ouverture maxi AE",
+"aemaxaperture2" : "Ouverture maxi AE (2)",
+"aemeteringmode" : "Mode de mesure AE",
+"multisegment" : "Multizone",
+"aemeteringsegments" : "Segments de mesure AE",
+"aeminaperture" : "Ouverture mini AE",
+"aeminexposuretime" : "Temps d\'exposition mini AE",
+"aeprogrammode" : "Mode programme AE",
+"av,borx" : "Av, B ou X",
+"candlelight" : "Eclairage Bougie",
+"dofprogram" : "Programme PdC",
+"dofprogram(pshift)" : "Programme PdC (décalage P)",
+"hispeedprogram" : "Programme grande vitesse",
+"hispeedprogram(pshift)" : "Programme grande vitesse (décalage P)",
+"kids" : "Enfants",
+"landscape" : "Paysage",
+"m,portav" : "M, P ou TAv",
+"mtfprogram" : "Programme FTM",
+"mtfprogram(pshift)" : "Programme FTM (décalage P)",
+"museum" : "Musée",
+"nightscene" : "Nocturne",
+"nightsceneportrait" : "Portrait nocturne",
+"noflash" : "Sans flash",
+"pet" : "Animal domestique",
+"sunset" : "Coucher de soleil",
+"surf&snow" : "Surf et neige",
+"svorgreenmode" : "Sv ou mode vert",
+"text" : "Texte",
+"aexv" : "Compensation d\'exposition auto",
+"ae_iso" : "Sensibilité ISO AE",
+"afadjustment" : "Ajustement AF",
+"afaperture" : "Ouverture AF",
+"afareamode" : "Mode de zone AF",
+"1area" : "Mise au point 1 zone",
+"1area(highspeed)" : "Mise au point 1 zone (haute vitesse)",
+"3area(center)?" : "Mise au point 3 zones (au centre) ?",
+"3area(highspeed)" : "Mise au point 3 zones (haute vitesse)",
+"3area(left)?" : "Mise au point 3 zones (à gauche) ?",
+"3area(right)?" : "Mise au point 3 zones (à droite) ?",
+"5area" : "Mise au point 5 zones",
+"9area" : "Mise au point 9 zones",
+"facedetectaf" : "AF en reconnaissance de visage",
+"spotfocusing" : "Mise au point Spot",
+"spotmodeoff" : "Mode Spot désactivé",
+"spotmodeon" : "Mode Spot enclenché",
+"afassist" : "Faisceau d\'assistance AF",
+"doesnotemit/fires" : "N\'émet pas/Se déclenche",
+"emits/doesnotfire" : "Emet/Ne se déclenche pas",
+"emits/fires" : "Emet/Se déclenche",
+"onlyext.flashemits/fires" : "Flash ext émet/Se déclenche",
+"afassistbeam" : "Faisceau d\'assistance AF",
+"doesnotemit" : "Désactivé",
+"emits" : "Activé",
+"onlyext.flashemits" : "Uniquement par flash ext.",
+"afdefocus" : "Défocalisation AF",
+"afduringliveview" : "AF pendant la visée directe",
+"disable" : "Désactivé",
+"enable" : "Activé",
+"livemode" : "Mode visée directe",
+"quickmode" : "Mode rapide",
+"afinfo" : "Info autofocus",
+"afinfo2" : "Infos AF",
+"afinfo2version" : "Version des infos AF",
+"afintegrationtime" : "Temps d\'intégration AF",
+"no" : "Non",
+"yes" : "Oui",
+"afmicroadjustment" : "Micro-ajustement de l\'AF",
+"adjustallbysameamount" : "Ajuster idem tous obj",
+"adjustbylens" : "Ajuster par objectif",
+"afmode" : "Mode AF",
+"afonaelockbuttonswitch" : "Permutation touche AF/Mémo",
+"afpoint" : "Point AF",
+"bottom" : "Bas",
+"center" : "Centre",
+"farleft" : "Extrème-gauche",
+"farright" : "Extrème-droit",
+"left" : "Gauche",
+"lowerleft" : "Bas gauche",
+"lowerright" : "Bas droit",
+"midleft" : "Milieu gauche",
+"midright" : "Milieu droit",
+"none" : "Aucune",
+"right" : "Droit",
+"top" : "Haut",
+"upperleft" : "Haut gauche",
+"upperright" : "Haut droite",
+"afpointactivationarea" : "Zone activation collimateurs AF",
+"automaticexpanded(max.13)" : "Expansion auto (13 max.)",
+"expanded(ttl.of7afpoints)" : "Expansion (TTL 7 collimat.)",
+"singleafpoint" : "Un seul collimateur AF",
+"afpointareaexpansion" : "Extension de la zone AF",
+"left/rightafpoints" : "Activé (gauche/droite collimateurs autofocus d\'assistance)",
+"surroundingafpoints" : "Activée (Collimateurs autofocus d\'assistance environnants)",
+"afpointautoselection" : "Sélecition des collimateurs automatique",
+"controldirect:disable/main:disable" : "Contrôle rapide-Directe:désactivé/Principale:désactivé",
+"controldirect:disable/main:enable" : "Contrôle rapide-Directe:désactivé/Principale:activé",
+"controldirect:enable/main:enable" : "Contrôle rapide-Directe:activé/Principale:activé",
+"afpointbrightness" : "Intensité d\'illumination AF",
+"brighter" : "Plus brillant",
+"normal" : "Normale",
+"afpointdisplayduringfocus" : "Affichage de point AF pendant mise au point",
+"on(whenfocusachieved)" : "Activé (si mise au point effectuée)",
+"afpointillumination" : "Eclairage des collimateurs AF",
+"onwithoutdimming" : "Activé sans atténuation",
+"afpointmode" : "Mode de mise au point AF",
+"afpointregistration" : "Validation du point AF",
+"automatic" : "Auto",
+"extremeleft" : "Extrême gauche",
+"extremeright" : "Extrême droite",
+"afpointselected" : "Point AF sélectionné",
+"automatictrackingaf" : "AF en suivi auto",
+"fixedcenter" : "Fixe au centre",
+"afpointselected2" : "Point AF sélectionné 2",
+"afpointselection" : "Sélection collimateur AF",
+"afpointselectionmethod" : "Méthode sélection collim. AF",
+"multicontrollerdirect" : "Multicontrôleur direct",
+"quickcontroldialdirect" : "Molette AR directe",
+"afpointspotmetering" : "Nombre collimateurs/mesure spot",
+"11/activeafpoint" : "11/collimateur AF actif",
+"11/centerafpoint" : "11/collimateur AF central",
+"45/centerafpoint" : "45/collimateur AF central",
+"9/activeafpoint" : "9/collimateur AF actif",
+"afpointsinfocus" : "Points AF nets",
+"all" : "Tous",
+"bottom,center" : "Bas + centre",
+"bottomcenter" : "Bas centre",
+"bottomleft" : "Bas gauche",
+"bottomright" : "Bas droit",
+"center(horizontal)" : "Centre (horizontal)",
+"center(vertical)" : "Centre (vertical)",
+"center+right" : "Centre+droit",
+"fixedcenterormultiple" : "Centre fixe ou multiple",
+"left+center" : "Gauch+centre",
+"left+right" : "Gauche+droit",
+"lowerleft,bottom" : "Bas gauche + bas",
+"lowerleft,midleft" : "Bas gauche + milieu gauche",
+"lowerright,bottom" : "Bas droit + bas",
+"lowerright,midright" : "Bas droit + milieu droit",
+"midleft,center" : "Milieu gauche + centre",
+"midright,center" : "Milieu droit + centre",
+"none(mf)" : "Aucune (MF)",
+"top,center" : "Haut + centre",
+"topcenter" : "Haut centre",
+"topleft" : "Haut gauche",
+"topright" : "Haut droit",
+"upperleft,midleft" : "Haut gauche + milieu gauche",
+"upperleft,top" : "Haut gauche + haut",
+"upperright,midright" : "Haut droit + milieu droit",
+"upperright,top" : "Haut droit + haut",
+"afpointsselected" : "Points AF sélectionnés",
+"central9points" : "9 points centraux",
+"afpointsunknown2" : "Points AF inconnus 2",
+"afpointsused" : "Points AF utilisés",
+"afpredictor" : "Prédicteur AF",
+"afresponse" : "Réponse AF",
+"aiservocontinuousshooting" : "Priorité vit. méca. AI Servo",
+"aiservoimagepriority" : "1er Servo Ai/2e priorité déclenchement",
+"1:af,2:drivespeed" : "Priorité AF/Priorité cadence vues",
+"1:af,2:tracking" : "Priorité AF/Priorité suivi AF",
+"1:release,2:drivespeed" : "Déclenchement/Priorité cadence vues",
+"aiservotrackingmethod" : "Méthode de suivi autofocus AI Servo",
+"continuousaftrackpriority" : "Priorité suivi AF en continu",
+"mainfocuspointpriority" : "Priorité point AF principal",
+"aiservotrackingsensitivity" : "Sensibili. de suivi AI Servo",
+"fast" : "Schnell",
+"mediumfast" : "Moyenne rapide",
+"mediumslow" : "Moyenne lent",
+"moderatelyfast" : "Moyennement rapide",
+"moderatelyslow" : "Moyennement lent",
+"slow" : "Lent",
+"apeversion" : "Version APE",
+"armidentifier" : "Identificateur ARM",
+"armversion" : "Version ARM",
+"atob0" : "A à B0",
+"atob1" : "A à B1",
+"atob2" : "A à B2",
+"accessorytype" : "Type d\'accessoire",
+"actionadvised" : "Action conseillée",
+"objectkill" : "Destruction d\'objet",
+"objectreference" : "Référence d\'objet",
+"objectreplace" : "Remplacement d\'objet",
+"ojbectappend" : "Ajout d\'objet",
+"activearea" : "Zone active",
+"low" : "Bas",
+"addaspectratioinfo" : "Ajouter info ratio d\'aspect",
+"addoriginaldecisiondata" : "Aj. données décis. origine",
+"additionalmodelinformation" : "Modele d\'Information additionnel",
+"address" : "Adresse",
+"unknown" : "Inconnu",
+"advisory" : "Adversité",
+"analogbalance" : "Balance analogique",
+"annotations" : "Annotations Photoshop",
+"n/a" : "Non établie",
+"antialiasstrength" : "Puissance relative du filtre anticrénelage de l\'appareil",
+"aperture" : "Ouverture",
+"aperturerange" : "Régler gamme d\'ouvertures",
+"apertureringuse" : "Utilisation de la bague de diaphragme",
+"permitted" : "Autorisée",
+"prohibited" : "Interdite",
+"aperturevalue" : "Ouverture",
+"applicationrecordversion" : "Version d\'enregistrement",
+"applyshootingmeteringmode" : "Appliquer mode de prise de vue/de mesure",
+"artist" : "Artiste",
+"artworkcopyrightnotice" : "Notice copyright de l\'Illustration",
+"artworkcreator" : "Créateur de l\'Illustration",
+"artworkdatecreated" : "Date de création de l\'Illustration",
+"artworksource" : "Source de l\'Illustration",
+"artworksourceinventoryno" : "No d\'Inventaire du source de l\'Illustration",
+"artworktitle" : "Titre de l\'Illustration",
+"asshoticcprofile" : "Profil ICC à la prise de vue",
+"asshotneutral" : "Balance neutre à la prise de vue",
+"asshotpreprofilematrix" : "Matrice de pré-profil à la prise de vue",
+"asshotprofilename" : "Nom du profil du cliché",
+"asshotwhitexy" : "Balance blanc X-Y à la prise de vue",
+"assignfuncbutton" : "Changer fonct. touche FUNC.",
+"exposurecomp./aebsetting" : "Correct. expo/réglage AEB",
+"imagejumpwithmaindial" : "Saut image par molette principale",
+"imagequality" : "Changer de qualité",
+"lcdbrightness" : "Luminosité LCD",
+"liveviewfunctionsettings" : "Réglages Visée par l’écran",
+"assistbuttonfunction" : "Touche de fonction rapide",
+"av+/(afpointbyqcd)" : "Av+/- (AF par mol. AR)",
+"felock" : "Mémo expo. au flash",
+"selecthp(whilepressing)" : "Sélect. HP (en appuyant)",
+"selecthomeposition" : "Sélect. position origine",
+"audioduration" : "Durée audio",
+"audiooutcue" : "Queue audio",
+"audiosamplingrate" : "Taux d\'échantillonnage audio",
+"audiosamplingresolution" : "Résolution d\'échantillonnage audio",
+"audiotype" : "Type audio",
+"monoactuality" : "Actualité (audio mono (1 canal))",
+"monomusic" : "Musique, transmise par elle-même (audio mono (1 canal))",
+"monoquestionandanswersession" : "Question et réponse (audio mono (1 canal))",
+"monorawsound" : "Son brut (audio mono (1 canal))",
+"monoresponsetoaquestion" : "Réponse à une question (audio mono (1 canal))",
+"monoscener" : "Scener (audio mono (1 canal))",
+"monovoicer" : "Voix (audio mono (1 canal))",
+"monowrap" : "Wrap (audio mono (1 canal))",
+"stereoactuality" : "Actualité (audio stéréo (2 canaux))",
+"stereomusic" : "Musique, transmise par elle-même (audio stéréo (2 canaux))",
+"stereoquestionandanswersession" : "Question et réponse (audio stéréo (2 canaux))",
+"stereorawsound" : "Son brut (audio stéréo (2 canaux))",
+"stereoresponsetoaquestion" : "Réponse à une question (audio stéréo (2 canaux))",
+"stereoscener" : "Scener (audio stéréo (2 canaux))",
+"stereovoicer" : "Voix (audio stéréo (2 canaux))",
+"stereowrap" : "Wrap (audio stéréo (2 canaux))",
+"textonly" : "Texte seul (pas de données d\'objet)",
+"author" : "Auteur",
+"authorsposition" : "Titre du créateur",
+"autoaperture" : "Auto-diaph",
+"autobracketing" : "Bracketing auto",
+"autolightingoptimizer" : "Correction auto de luminosité",
+"strong" : "Importante",
+"autorotate" : "Rotation automatique",
+"rotate180" : "180° (bas/droit)",
+"rotate270cw" : "90° sens horaire (gauche/bas)",
+"rotate90cw" : "90° sens antihoraire (droit/haut)",
+"auxiliarylens" : "Objectif Auxiliaire",
+"avaperturesetting" : "Réglage d\'ouverture Av",
+"avsettingwithoutlens" : "Réglage Av sans objectif",
+"btoa0" : "B à A0",
+"btoa1" : "B à A1",
+"btoa2" : "B à A2",
+"backgroundcolorindicator" : "Indicateur de couleur d\'arrière-plan",
+"backgroundcolorvalue" : "Valeur de couleur d\'arrière-plan",
+"badfaxlines" : "Mauvaises lignes de Fax",
+"baseexposurecompensation" : "Compensation d\'exposition de base",
+"baseurl" : "URL de base",
+"baselineexposure" : "Exposition de base",
+"baselinenoise" : "Bruit de base",
+"baselinesharpness" : "Accentuation de base",
+"batteryinfo" : "Source d\'alimentation",
+"batterylevel" : "Niveau de batterie",
+"bayergreensplit" : "Séparation de vert Bayer",
+"high" : "Haut",
+"bestqualityscale" : "Echelle de meilleure qualité",
+"bitspercomponent" : "Bits par composante",
+"bitsperextendedrunlength" : "Bits par « Run Length » étendue",
+"bitsperrunlength" : "Bits par « Run Length »",
+"bitspersample" : "Nombre de bits par échantillon",
+"blacklevel" : "Niveau noir",
+"blackleveldeltah" : "Delta H du niveau noir",
+"blackleveldeltav" : "Delta V du niveau noir",
+"blacklevelrepeatdim" : "Dimension de répétition du niveau noir",
+"blackpoint" : "Point noir",
+"bluebalance" : "Balance bleue",
+"bluematrixcolumn" : "Colonne de matrice bleue",
+"bluetrc" : "Courbe de reproduction des tons bleus",
+"bodybatteryadload" : "Tension accu boîtier en charge",
+"bodybatteryadnoload" : "Tension accu boîtier à vide",
+"bodybatterystate" : "État de accu boîtier",
+"almostempty" : "Presque vide",
+"emptyormissing" : "Vide ou absent",
+"full" : "Pleine",
+"runninglow" : "En baisse",
+"bracketshotnumber" : "Numéro de cliché en bracketing",
+"1of3" : "1 sur 3",
+"1of5" : "1 sur 5",
+"2of3" : "2 sur 3",
+"2of5" : "2 sur 5",
+"3of3" : "3 sur 3",
+"3of5" : "3 sur 5",
+"4of5" : "4 sur 5",
+"5of5" : "5 sur 5",
+"brightness" : "Luminosité",
+"brightnessvalue" : "Luminosité",
+"bulbduration" : "Durée du pose longue",
+"burstmode" : "Mode Rafale",
+"infinite" : "Infini",
+"buttonfunctioncontroloff" : "Fonction de touche si Contrôle Rapide OFF",
+"disablemain,control,multicontrol" : "Désactivés principale, Contrôle rapide, Multicontrôleur",
+"normal(enable)" : "Normale (activée)",
+"byline" : "Créateur",
+"bylinetitle" : "Fonction du créateur",
+"cfalayout" : "Organisation CFA",
+"evencolumnsoffsetdown1/2row" : "Organisation décalée A : les colonnes paires sont décalées vers le bas d\'une demi-rangée.",
+"evencolumnsoffsetup1/2row" : "Organisation décalée B : les colonnes paires sont décalées vers le haut d\'une demi-rangée.",
+"evenrowsoffsetleft1/2column" : "Organisation décalée D : les rangées paires sont décalées vers la gauche d\'une demi-colonne.",
+"evenrowsoffsetright1/2column" : "Organisation décalée C : les rangées paires sont décalées vers la droite d\'une demi-colonne.",
+"rectangular" : "Plan rectangulaire (ou carré)",
+"cfapattern" : "Matrice de filtrage couleur",
+"cfapattern2" : "Modèle CFA 2",
+"cfaplanecolor" : "Couleur de plan CFA",
+"cfarepeatpatterndim" : "Dimension du modèle de répétition CFA",
+"cmmflags" : "Drapeaux CMM",
+"cmykequivalent" : "Equivalent CMJK",
+"cpufirmwareversion" : "Version de firmware de CPU",
+"calibrationdatetime" : "Date et heure de calibration",
+"calibrationilluminant1" : "Illuminant de calibration 1",
+"cloudy" : "Temps nuageux",
+"coolwhitefluorescent" : "Fluorescente type soft",
+"daywhitefluorescent" : "Fluorescent blanc jour",
+"daylight" : "Lumière du jour",
+"daylightfluorescent" : "Fluorescente type jour",
+"fineweather" : "Beau temps",
+"fluorescent" : "Fluorescente",
+"isostudiotungsten" : "Tungstène studio ISO",
+"other" : "Autre",
+"shade" : "Ombre",
+"standardlighta" : "Lumière standard A",
+"standardlightb" : "Lumière standard B",
+"standardlightc" : "Lumière standard C",
+"tungsten(incandescent)" : "Tungstène (lumière incandescente)",
+"warmwhitefluorescent" : "Fluorescent blanc chaud",
+"whitefluorescent" : "Fluorescent blanc",
+"calibrationilluminant2" : "Illuminant de calibration 2",
+"cameracalibration1" : "Calibration d\'appareil 1",
+"cameracalibration2" : "Calibration d\'appareil 2",
+"cameracalibrationsig" : "Signature de calibration de l\'appareil",
+"cameraorientation" : "Orientation de l\'image",
+"horizontal(normal)" : "0° (haut/gauche)",
+"cameraserialnumber" : "Numéro de série de l\'appareil",
+"camerasettings" : "Réglages de l\'appareil",
+"cameratemperature" : "Température de l\'appareil",
+"cameratype" : "Type d\'objectif Pentax",
+"aperturepriorityae" : "Priorité ouverture",
+"bulb" : "Pose B",
+"manual" : "Manuelle",
+"programae" : "Programme AE",
+"shutterspeedpriorityae" : "Priorité vitesse",
+"canonfirmwareversion" : "Version de firmware",
+"redeyereduction" : "Réduction yeux rouges",
+"large" : "Grande",
+"medium" : "Moyenne",
+"medium1" : "Moyenne 1",
+"medium2" : "Moyenne 2",
+"medium3" : "Moyenne 3",
+"small" : "Petite",
+"small1" : "Petite 1",
+"small2" : "Petite 2",
+"small3" : "Petite 3",
+"captionabstract" : "Légende / Description",
+"captionwriter" : "Rédacteur",
+"um" : "µm (micromètre)",
+"categories" : "Catégories",
+"category" : "Catégorie",
+"celllength" : "Longueur de cellule",
+"cellwidth" : "Largeur de cellule",
+"average" : "Moyenne",
+"certificate" : "Certificat",
+"chartarget" : "Cible caractère",
+"characterset" : "Jeu de caractères",
+"chromablurradius" : "Rayon de flou de chromatisme",
+"chromaticadaptation" : "Adaptation chromatique",
+"chromaticity" : "Chromaticité",
+"circleofconfusion" : "Cercle de confusion",
+"city" : "Ville",
+"classifystate" : "Etat de classification",
+"cleanfaxdata" : "Données de Fax propres",
+"clippath" : "Chemin de rognage",
+"codedcharacterset" : "Jeu de caractères codé",
+"colorbalance" : "Balance des couleurs",
+"colorcalibrationmatrix" : "Table de matrice de calibration de couleur",
+"colorcharacterization" : "Caractérisation de couleur",
+"colorcomponents" : "Composants colorimétriques",
+"coloreffect" : "Effet de couleurs",
+"black&white" : "Monochrome",
+"cool" : "Froide",
+"sepia" : "Sépia",
+"warm" : "Chaude",
+"colorfilter" : "Filtre de couleur",
+"blue" : "Bleu",
+"green" : "Vert",
+"red" : "Rouge",
+"yellow" : "Jaune",
+"colorhue" : "Teinte de couleur",
+"colorinfo" : "Info couleur",
+"colormap" : "Charte de couleur",
+"colormatrix1" : "Matrice de couleur 1",
+"colormatrix2" : "Matrice de couleur 2",
+"colormode" : "Mode colorimétrique",
+"adobergb" : "AdobeRVB",
+"autumnleaves" : "Feuilles automne",
+"b&w" : "Noir & Blanc",
+"clear" : "Lumineux",
+"deep" : "Profond",
+"evening" : "Soir",
+"light" : "Pastel",
+"natural" : "Naturel",
+"neutral" : "Neutre",
+"nightview" : "Vision nocturne",
+"nightview/portrait" : "Vision/portrait nocturne",
+"rgb" : "RVB",
+"vivid" : "Vives",
+"colorpalette" : "Palette de couleur",
+"colorrepresentation" : "Représentation de couleur",
+"3components,framesequentialinmultipleobjects" : "Trois composantes, Vue séquentielle dans différents objets",
+"3components,framesequentialinoneobject" : "Trois composantes, Vue séquentielle dans un objet",
+"3components,linesequential" : "Trois composantes, Ligne séquentielle",
+"3components,pixelsequential" : "Trois composantes, Pixel séquentiel",
+"3components,singleframe" : "Trois composantes, Vue unique",
+"3components,specialinterleaving" : "Trois composantes, Entrelacement spécial",
+"4components,framesequentialinmultipleobjects" : "Quatre composantes, Vue séquentielle dans différents objets",
+"4components,framesequentialinoneobject" : "Quatre composantes, Vue séquentielle dans un objet",
+"4components,linesequential" : "Quatre composantes, Ligne séquentielle",
+"4components,pixelsequential" : "Quatre composantes, Pixel séquentiel",
+"4components,singleframe" : "Quatre composantes, Vue unique",
+"4components,specialinterleaving" : "Quatre composantes, Entrelacement spécial",
+"monochrome,singleframe" : "Monochrome, Vue unique",
+"noimage,singleframe" : "Pas d\'image, Vue unique",
+"colorresponseunit" : "Unité de réponse couleur",
+"colorsequence" : "Séquence de couleur",
+"colorspace" : "Espace colorimétrique",
+"iccprofile" : "Profil ICC",
+"uncalibrated" : "Non calibré",
+"widegamutrgb" : "Wide Gamut RVB",
+"srgb" : "sRVB",
+"colorspacedata" : "Espace de couleur de données",
+"colortable" : "Tableau de couleurs",
+"colortemperature" : "Température de couleur",
+"colortone" : "Teinte couleur",
+"colorantorder" : "Ordre de colorant",
+"coloranttable" : "Table de coloranté",
+"colorimetricreference" : "Référence colorimétrique",
+"comment" : "Commentaire",
+"comments" : "Commentaires",
+"componentsconfiguration" : "Signification de chaque composante",
+"compressedbitsperpixel" : "Mode de compression d\'image",
+"compression" : "Schéma de compression",
+"jbigcolor" : "JBIG Couleur",
+"jpeg" : "Compression JPEG",
+"jpeg(oldstyle)" : "JPEG (ancien style)",
+"kodakdcrcompressed" : "Compression Kodak DCR",
+"kodakkdccompressed" : "Compression Kodak KDC",
+"next" : "Encodage NeXT 2 bits",
+"nikonnefcompressed" : "Compression Nikon NEF",
+"pentaxpefcompressed" : "Compression Pentax PEF",
+"sgilog" : "Encodage Log luminance SGI 32 bits",
+"sgilog24" : "Encodage Log luminance SGI 24 bits",
+"sonyarwcompressed" : "Compression Sony ARW",
+"thunderscan" : "Encodage ThunderScan 4 bits",
+"uncompressed" : "Non.comprimé",
+"conditionalfec" : "Compensation exposition flash",
+"connectionspaceilluminant" : "Illuminant d\'espace de connexion",
+"consecutivebadfaxlines" : "Mauvaises lignes de Fax consécutives",
+"contentlocationcode" : "Code du lieu du contenu",
+"contentlocationname" : "Nom du lieu du contenu",
+"movie" : "Vidéo",
+"continuousshootingspeed" : "Vitesse de prise de vues en continu",
+"continuousshotlimit" : "Limiter nombre de vues en continu",
+"contrast" : "Contraste",
+"medhigh" : "Assez forte",
+"medlow" : "Assez faible",
+"mediumhigh" : "Moyen Haut",
+"mediumlow" : "Moyen Faible",
+"veryhigh" : "Très forte",
+"verylow" : "Très faible",
+"contrastcurve" : "Courbe de contraste",
+"contributor" : "Contributeur",
+"conversionlens" : "Complément Optique",
+"telephoto" : "Télé",
+"wide" : "Grand angulaire",
+"copyright" : "Propriétaire du copyright",
+"copyrightnotice" : "Mention de copyright",
+"country" : "Pays",
+"countryprimarylocationcode" : "Code de pays ISO",
+"countryprimarylocationname" : "Pays",
+"countrycode" : "Code pays",
+"coverage" : "Couverture",
+"createdate" : "Date de la création des données numériques",
+"creationdate" : "Date de création",
+"creator" : "Créateur",
+"creatoraddress" : "Adresse du créateur",
+"creatorcity" : "Lieu d\'Habitation du créateur",
+"creatorcountry" : "Pays du créateur",
+"creatorpostalcode" : "Code postal du créateur",
+"creatorregion" : "Région du créateur",
+"creatortool" : "Outil de création",
+"creatorworkemail" : "Courriel professionnel du créateur",
+"creatorworktelephone" : "Téléphone professionnel créateur",
+"creatorworkurl" : "URL professionnelle du créateur",
+"credit" : "Fournisseur",
+"inches" : "Pouce",
+"currenticcprofile" : "Profil ICC actuel",
+"currentiptcdigest" : "Sommaire courant IPTC",
+"currentpreprofilematrix" : "Matrice de pré-profil actuelle",
+"customrendered" : "Traitement d\'image personnalisé",
+"custom" : "Personnalisée",
+"dngbackwardversion" : "Version DNG antérieure",
+"dnglensinfo" : "Distance focale minimale",
+"dngversion" : "Version DNG",
+"dof" : "Profondeur de champ",
+"dspfirmwareversion" : "Version de firmware de DSP",
+"datacompressionmethod" : "Fournisseur/propriétaire de l\'algorithme de compression de données",
+"datadump" : "Vidage données",
+"datatype" : "Type de données",
+"datecreated" : "Date de création",
+"datedisplayformat" : "Format date",
+"d/m/y" : "Jour/Mois/Année",
+"m/d/y" : "Mois/Jour/Année",
+"y/m/d" : "Année/Mois/Jour",
+"datesent" : "Date d\'envoi",
+"date&time" : "Date et heure",
+"datetime" : "Date de modification du fichier",
+"datetimecreated" : "Date/heure de création",
+"datetimedigitized" : "Date/heure de la numérisation",
+"datetimeoriginal" : "Date de la création des données originales",
+"daylightsavings" : "Heure d\'été",
+"defaultcroporigin" : "Origine de rognage par défaut",
+"defaultcropsize" : "Taille de rognage par défaut",
+"defaultscale" : "Echelle par défaut",
+"deletedimagecount" : "Compteur d\'images supprimées",
+"destinationcity" : "Ville de destination",
+"destinationcitycode" : "Code ville de destination",
+"destinationdst" : "Heure d\'été de destination",
+"deviceattributes" : "Attributs d\'appareil",
+"devicemanufacturer" : "Fabricant de l\'appareil",
+"devicemfgdesc" : "Description du fabricant d\'appareil",
+"devicemodel" : "Modèle de l\'appareil",
+"devicemodeldesc" : "Description du modèle d\'appareil",
+"devicesettingdescription" : "Description des réglages du dispositif",
+"dialdirectiontvav" : "Sens rotation molette Tv/Av",
+"reversed" : "Sens inversé",
+"digitalcreationdate" : "Date de numérisation",
+"digitalcreationtime" : "Heure de numérisation",
+"digitalimageguid" : "GUID de l\'image numérique",
+"digitalsourcefiletype" : "Type de fichier de la source numérique",
+"digitalzoom" : "Zoom numérique",
+"digitalzoomratio" : "Rapport de zoom numérique",
+"directory" : "Dossier",
+"directorynumber" : "Numéro de dossier",
+"djvuversion" : "Version DjVu",
+"documenthistory" : "Historique du document",
+"documentname" : "Nom du document",
+"documentnotes" : "Remarques sur le document",
+"dotrange" : "Étendue de points",
+"drivemode" : "Mode de prise de vue",
+"burst" : "Rafale",
+"continuous" : "Auto, continue",
+"continuoushigh" : "Continu (ultrarapide)",
+"continuousshooting" : "Prise de vues en continu",
+"multipleexposure" : "Exposition multiple",
+"notimer" : "Pas de retardateur",
+"remotecontrol" : "Télécommande",
+"remotecontrol(3sdelay)" : "Télécommande (retard 3 s)",
+"selftimer(12s)" : "Retardateur (12 s)",
+"selftimer(2s)" : "Retardateur (2 s)",
+"selftimeroperation" : "Retardateur",
+"shutterbutton" : "Déclencheur",
+"singleexposure" : "Exposition unique",
+"singleframe" : "Vue par vue",
+"singleframeshooting" : "Prise de vue unique",
+"drivemode2" : "Exposition multiple",
+"duration" : "Durée",
+"dynamicrangeexpansion" : "Expansion de la dynamique",
+"dynamicrangeoptimizer" : "Optimiseur Dyna",
+"advancedauto" : "Avancé Auto",
+"advancedlv1" : "Avancé Niv1",
+"advancedlv2" : "Avancé Niv2",
+"advancedlv3" : "Avancé Niv3",
+"advancedlv4" : "Avancé Niv4",
+"advancedlv5" : "Avancé Niv5",
+"auto" : "Equilibrage des blancs automatique",
+"pshift" : "Décalage P",
+"tvorav" : "Tv ou Av",
+"evaluative" : "Évaluative",
+"evstepinfo" : "Info de pas IL",
+"evsteps" : "Pas IL",
+"1/2evsteps" : "Pas de 1/2 IL",
+"1/3evsteps" : "Pas de 1/3 IL",
+"beach" : "Plage",
+"coloraccent" : "Couleur contrastée",
+"colorswap" : "Permuter couleur",
+"fireworks" : "Feu d\'artifice",
+"foliage" : "Feuillages",
+"indoor" : "Intérieur",
+"kids&pets" : "Enfants & animaux",
+"night" : "Scène de nuit",
+"nightsnapshot" : "Mode Nuit",
+"snow" : "Neige",
+"sports" : "Sport",
+"supermacro" : "Super macro",
+"underwater" : "Subaquatique",
+"editstatus" : "Statut d\'édition",
+"editorialupdate" : "Mise à jour éditoriale",
+"additionallanguage" : "Langues supplémentaires",
+"effectivelv" : "Indice de lumination effectif",
+"effectivemaxaperture" : "Ouverture effective maxi de l\'Objectif",
+"encodingprocess" : "Procédé de codage",
+"baselinedct,huffmancoding" : "Baseline DCT, codage Huffman",
+"extendedsequentialdct,huffmancoding" : "Extended sequential DCT, codage Huffman",
+"extendedsequentialdct,arithmeticcoding" : "Extended sequential DCT, codage arithmétique",
+"lossless,differentialhuffmancoding" : "Lossless, codage Huffman différentiel",
+"lossless,huffmancoding" : "Lossless, codage Huffman",
+"lossless,arithmeticcoding" : "Lossless, codage arithmétique",
+"lossless,differentialarithmeticcoding" : "Lossless, codage arithmétique différentiel",
+"progressivedct,huffmancoding" : "Progressive DCT, codage Huffman",
+"progressivedct,arithmeticcoding" : "Progressive DCT, codage arithmétique",
+"progressivedct,differentialhuffmancoding" : "Progressive DCT, codage Huffman différentiel",
+"progressivedct,differentialarithmeticcoding" : "Progressive DCT, codage arithmétique différentiel",
+"sequentialdct,differentialhuffmancoding" : "Sequential DCT, codage Huffman différentiel",
+"sequentialdct,differentialarithmeticcoding" : "Sequential DCT, codage arithmétique différentiel",
+"encryption" : "Chiffrage",
+"endpoints" : "Points de terminaison",
+"envelopenumber" : "Numéro d\'enveloppe",
+"envelopepriority" : "Priorité d\'enveloppe",
+"0(reserved)" : "0 (réservé pour utilisation future)",
+"1(mosturgent)" : "1 (très urgent)",
+"5(normalurgency)" : "5 (normalement urgent)",
+"8(leasturgent)" : "8 (moins urgent)",
+"9(userdefinedpriority)" : "9 (réservé pour utilisation future)",
+"enveloperecordversion" : "Version d\'enregistrement",
+"error" : "Erreur",
+"event" : "Evenement",
+"excursiontolerance" : "Tolérance d\'excursion ",
+"allowed" : "Possible",
+"notallowed" : "Non permis (défaut)",
+"exifbyteorder" : "Indicateur d\'ordre des octets Exif",
+"exifcamerainfo" : "Info d\'appareil photo Exif",
+"exifimageheight" : "Hauteur d\'image",
+"exifimagewidth" : "Largeur d\'image",
+"exifoffset" : "Pointeur Exif IFD",
+"exiftoolversion" : "Version ExifTool",
+"exifunicodebyteorder" : "Indicateur d\'ordre des octets Unicode Exif",
+"exifversion" : "Version Exif",
+"exitpupilposition" : "Position de la pupille de sortie",
+"expandfilm" : "Extension film",
+"expandfilterlens" : "Extension lentille filtre",
+"expandflashlamp" : "Extension lampe flash",
+"expandlens" : "Extension objectif",
+"expandscanner" : "Extension Scanner",
+"expandsoftware" : "Extension logiciel",
+"expirationdate" : "Date d\'expiration",
+"expirationtime" : "Heure d\'expiration",
+"exposurebracketstepsize" : "Intervalle de bracketing d\'exposition",
+"exposurebracketvalue" : "Valeur Bracketing Expo",
+"exposurecompensation" : "Décalage d\'exposition",
+"exposuredifference" : "Correction d\'exposition",
+"exposureindex" : "Indice d\'exposition",
+"exposurelevelincrements" : "Paliers de réglage d\'expo",
+"1stopset,1/3stopcomp." : "Réglage 1 valeur, correction 1/3 val.",
+"1/2stop" : "Palier 1/2",
+"1/2stopset,1/2stopcomp." : "Réglage 1/2 valeur, correction 1/2 val.",
+"1/3stop" : "Palier 1/3",
+"1/3stopset,1/3stopcomp." : "Réglage 1/3 valeur, correction 1/3 val.",
+"exposuremode" : "Mode d\'exposition",
+"aperturepriority" : "Priorité ouverture",
+"autobracket" : "Bracketting auto",
+"nightscene/twilight" : "Nocturne",
+"shutterpriority" : "Priorité vitesse",
+"exposuremodeinmanual" : "Mode d\'exposition manuelle",
+"centerweightedaverage" : "Centrale pondérée",
+"evaluativemetering" : "Mesure évaluativ",
+"partialmetering" : "Partielle",
+"specifiedmeteringmode" : "Mode de mesure spécifié",
+"spotmetering" : "Spot",
+"exposureprogram" : "Programme d\'exposition",
+"action(highspeed)" : "Programme action (orienté grandes vitesses d\'obturation)",
+"creative(slowspeed)" : "Programme créatif (orienté profondeur de champ)",
+"notdefined" : "Non définie",
+"portrait" : "Mode portrait",
+"exposuretime" : "Temps de pose",
+"exposuretime2" : "Temps de pose 2",
+"attached" : "Attaché",
+"notattached" : "Non attaché",
+"removed" : "Retiré",
+"externalflashbounce" : "Réflexion flash externe",
+"bounce" : "Avec réflecteur",
+"externalflashexposurecomp" : "Compensation d\'exposition flash externe",
+"0.5" : "0.5 IL",
+"1.0" : "1.0 IL",
+"1.5" : "-1.5 IL",
+"2.0" : "-2.0 IL",
+"2.5" : "-2.5 IL",
+"3.0" : "-3.0 IL",
+"0.0" : "0.0 IL",
+"n/a(manualmode)" : "Non établie (mode manuel)",
+"externalflashguidenumber" : "Nombre guide flash externe",
+"externalflashmode" : "Segment de mesure flash esclave 3",
+"on,auto" : "En service, auto",
+"on,contrastcontrolsync" : "En service, synchro contrôle des contrastes",
+"on,flashproblem" : "En service, problème de flash",
+"on,highspeedsync" : "En service, synchro haute vitesse",
+"on,manual" : "En service, manuel",
+"on,pttlauto" : "En service, auto P-TTL",
+"on,wireless" : "En service, sans cordon",
+"on,wireless,highspeedsync" : "En service, sans cordon, synchro haute vitesse",
+"n/aoffautoaperture" : "N/c - auto-diaph hors service",
+"extrasamples" : "Echantillons supplémentaires",
+"fnumber" : "Nombre F",
+"fov" : "Champ de vision",
+"faxrecvparams" : "Paramètres de réception Fax",
+"faxrecvtime" : "Temps de réception Fax",
+"faxsubaddress" : "Sous-adresse Fax",
+"fileformat" : "Format de fichier",
+"fileinfo" : "Infos Fichier",
+"fileinfoversion" : "Version des Infos Fichier",
+"filemodifydate" : "Date/heure de modification du fichier",
+"filename" : "Nom de fichier",
+"filenumber" : "Numéro de fichier",
+"filesize" : "Taille du fichier",
+"filesource" : "Source du fichier",
+"digitalcamera" : "Appareil photo numérique",
+"filmscanner" : "Scanner de film",
+"reflectionprintscanner" : "Scanner par réflexion",
+"filetype" : "Type de fichier",
+"fileversion" : "Version de format de fichier",
+"fillflashautoreduction" : "Mesure E-TTL",
+"fillorder" : "Ordre de remplissage",
+"filmmode" : "Mode Film",
+"dynamic(b&w)" : "Vives (N & Bà)",
+"dynamic(color)" : "Couleurs vives",
+"nature(color)" : "Couleurs naturelles",
+"smooth(b&w)" : "Pastel (N & B)",
+"smooth(color)" : "Couleurs pastel",
+"standard(b&w)" : "Normales (N & B)",
+"standard(color)" : "Couleurs normales",
+"filtereffect" : "Effet de filtre",
+"finderdisplayduringexposure" : "Affich. viseur pendant expo.",
+"firmwareversion" : "Version de firmware",
+"fixtureidentifier" : "Identificateur d\'installation",
+"flash" : "Flash ",
+"auto,didnotfire" : "Auto, non déclenché",
+"auto,didnotfire,redeyereduction" : "Auto, non déclenché, réduction yeux rouges",
+"auto,fired" : "Auto, déclenché",
+"auto,fired,redeyereduction" : "Auto, déclenché, réduction yeux rouges",
+"auto,fired,redeyereduction,returndetected" : "Flash déclenché, mode auto, lumière renvoyée détectée, mode réduction yeux rouges",
+"auto,fired,redeyereduction,returnnotdetected" : "Flash déclenché, mode auto, lumière renvoyée non détectée, mode réduction yeux rouges",
+"auto,fired,returndetected" : "Flash déclenché, mode auto, lumière renvoyée détectée",
+"auto,fired,returnnotdetected" : "Flash déclenché, mode auto, lumière renvoyée non détectée",
+"didnotfire" : "Eclair non-déclenché",
+"fired" : "Activé",
+"fired,redeyereduction" : "En service, réduction yeux rouges",
+"fired,redeyereduction,returndetected" : "Flash déclenché, mode réduction yeux rouges, lumière renvoyée détectée",
+"fired,redeyereduction,returnnotdetected" : "Flash déclenché, mode réduction yeux rouges, lumière renvoyée non détectée",
+"fired,returndetected" : "Lumière renvoyée sur le capteur détectée",
+"fired,returnnotdetected" : "Lumière renvoyée sur le capteur non détectée",
+"noflashfunction" : "Pas de fonction flash",
+"off,didnotfire" : "Hors service",
+"off,didnotfire,returnnotdetected" : "Éteint, flash non déclenché, lumière renvoyée non détectée",
+"off,noflashfunction" : "Éteint, pas de fonction flash",
+"off,redeyereduction" : "Éteint, mode réduction yeux rouges",
+"on,didnotfire" : "En service, non déclenché",
+"on,fired" : "En service",
+"on,redeyereduction" : "En service, réduction yeux rouges",
+"on,redeyereduction,returndetected" : "Flash déclenché, mode forcé, mode réduction yeux rouges, lumière renvoyée détectée",
+"on,redeyereduction,returnnotdetected" : "Flash déclenché, mode forcé, mode réduction yeux rouges, lumière renvoyée non détectée",
+"on,returndetected" : "Flash déclenché, mode flash forcé, lumière renvoyée détectée",
+"on,returnnotdetected" : "Flash déclenché, mode flash forcé, lumière renvoyée non détectée",
+"flashbias" : "Décalage Flash",
+"flashcompensation" : "Compensation flash",
+"flashcontrolmode" : "Mode de Contrôle du Flash",
+"flashenergy" : "Énergie du flash",
+"flashexposurebracketvalue" : "Valeur Bracketing Flash",
+"flashexposurecomp" : "Compensation d\'exposition au flash",
+"flashexposurecompset" : "Réglage de compensation d\'exposition au flash",
+"flashfired" : "Flash utilisé",
+"flashfiring" : "Émission de l\'éclair",
+"doesnotfire" : "Désactivé",
+"fires" : "Activé",
+"flashfocallength" : "Focale Flash",
+"flashfunction" : "Fonction flash",
+"flashinfo" : "Information flash",
+"flashinfoversion" : "Version de l\'info Flash",
+"flashmeteringsegments" : "Segments de mesure flash",
+"flashmode" : "Mode flash",
+"external,auto" : "Externe, auto",
+"external,contrastcontrolsync" : "Externe, synchro contrôle des contrastes",
+"external,flashproblem" : "Externe, problème de flash ?",
+"external,highspeedsync" : "Externe, synchro haute vitesse",
+"external,manual" : "Externe, manuel",
+"external,pttlauto" : "Externe, P-TTL",
+"external,wireless" : "Externe, sans cordon",
+"external,wireless,highspeedsync" : "Externe, sans cordon, synchro haute vitesse",
+"fired,commandermode" : "Eclair déclenché, Mode maître",
+"fired,external" : "Eclair déclenché, Exterieur",
+"fired,manual" : "Eclair déclenché, Manuel",
+"fired,ttlmode" : "Eclair déclenché, Mode TTL",
+"internal" : "Interne",
+"on,slowsync" : "En service, synchro lente",
+"on,slowsync,redeyereduction" : "En service, synchro lente, réduction yeux rouges",
+"on,soft" : "En service, doux",
+"on,trailingcurtainsync" : "En service, synchro 2e rideau",
+"on,wireless(control)" : "En service, sans cordon (esclave)",
+"on,wireless(master)" : "En service, sans cordon (maître)",
+"flashmodel" : "Modèle de Flash",
+"flashoptions" : "Options de flash",
+"auto,redeyereduction" : "Auto, réduction yeux rouges",
+"slowsync" : "Synchro lente",
+"slowsync,redeyereduction" : "Synchro lente, réduction yeux rouges",
+"trailingcurtainsync" : "Synchro 2e rideau",
+"wireless(control)" : "Sans cordon (contrôleur)",
+"wireless(master)" : "Sans cordon (maître)",
+"flashoptions2" : "Options de flash (2)",
+"flashoutput" : "Puissance de l\'éclair",
+"flashredeyemode" : "Flash mode anti-yeux rouges",
+"noreturndetection" : "Pas de détection de retour",
+"returndetected" : "Retour détecté",
+"returnnotdetected" : "Retour non détecté",
+"flashsetting" : "Réglages Flash",
+"flashstatus" : "Segment de mesure flash esclave 1",
+"external,didnotfire" : "Externe, non déclenché",
+"external,fired" : "Externe, déclenché",
+"internal,didnotfire" : "Interne, non déclenché",
+"internal,fired" : "Interne, déclenché",
+"flashsyncspeedav" : "Vitesse synchro en mode Av",
+"1/200fixed" : "1/200 fixe",
+"1/250fixed" : "1/250 fixe",
+"1/300fixed" : "1/300 fixe",
+"flashtype" : "Type de flash",
+"builtinflash" : "Intégré",
+"external" : "Externe",
+"flashpixversion" : "Version Flashpix supportée",
+"focallength" : "Focale de l\'objectif",
+"focallength35efl" : "Focale de l\'objectif",
+"focallengthin35mmformat" : "Distance focale sur film 35 mm",
+"focalplaneresolutionunit" : "Unité de résolution de plan focal",
+"focalplanexresolution" : "Résolution X du plan focal",
+"focalplaneyresolution" : "Résolution Y du plan focal",
+"focusdistance" : "Distance de mise au point",
+"focusmode" : "Mode mise au point",
+"afc" : "AF-C (prise de vue en rafale)",
+"afs" : "AF-S (prise de vue unique)",
+"auto,continuous" : "Auto, continue",
+"auto,focusbutton" : "Bouton autofocus",
+"infinity" : "Infini",
+"panfocus" : "Hyperfocale",
+"focusmode2" : "Mode mise au point 2",
+"focusposition" : "Distance de mise au point",
+"focusingscreen" : "Verre de visée",
+"forwardmatrix1" : "Matrice forward 1",
+"forwardmatrix2" : "Matrice forward 2",
+"framenumber" : "Numéro de vue",
+"framerate" : "Vitesse",
+"framesize" : "Taille du cadre",
+"freebytecounts" : "Nombre d\'octets libres",
+"freeoffsets" : "Offsets libres",
+"gifversion" : "Version GIF",
+"gpsaltitude" : "Altitude",
+"gpsaltituderef" : "Référence d\'altitude",
+"abovesealevel" : "Au-dessus du niveau de la mer",
+"belowsealevel" : "En-dessous du niveau de la mer",
+"gpsareainformation" : "Nom de la zone GPS",
+"gpsdop" : "Précision de mesure",
+"gpsdatestamp" : "Date GPS",
+"gpsdatetime" : "Heure GPS (horloge atomique)",
+"gpsdestbearing" : "Orientation de la destination",
+"gpsdestbearingref" : "Référence de l\'orientation de la destination",
+"magneticnorth" : "Direction magnétique",
+"truenorth" : "Direction vraie",
+"gpsdestdistance" : "Distance à la destination",
+"gpsdestdistanceref" : "Référence de la distance à la destination",
+"kilometers" : "Kilomètres",
+"nauticalmiles" : "Noeuds",
+"gpsdestlatitude" : "Latitude de destination",
+"gpsdestlatituderef" : "Référence de la latitude de destination",
+"north" : "Latitude nord",
+"south" : "Latitude sud",
+"gpsdestlongitude" : "Longitude de destination",
+"gpsdestlongituderef" : "Référence de la longitude de destination",
+"east" : "Longitude est",
+"west" : "Longitude ouest",
+"gpsdifferential" : "Correction différentielle GPS",
+"differentialcorrected" : "Correction différentielle appliquée",
+"nocorrection" : "Mesure sans correction différentielle",
+"gpsimgdirection" : "Direction de l\'image",
+"gpsimgdirectionref" : "Référence pour la direction l\'image",
+"gpsinfo" : "Pointeur IFD d\'informations GPS",
+"gpslatitude" : "Latitude",
+"gpslatituderef" : "Latitude nord ou sud",
+"gpslongitude" : "Longitude",
+"gpslongituderef" : "Longitude est ou ouest",
+"gpsmapdatum" : "Données de surveillance géodésique utilisées",
+"gpsmeasuremode" : "Mode de mesure GPS",
+"2d" : "Mesure à deux dimensions",
+"2dimensional" : "Mesure à deux dimensions",
+"2dimensionalmeasurement" : "Mesure à deux dimensions",
+"3d" : "Mesure à trois dimensions",
+"3dimensional" : "Mesure à trois dimensions",
+"3dimensionalmeasurement" : "Mesure à trois dimensions",
+"gpsposition" : "Position GPS",
+"gpsprocessingmethod" : "Nom de la méthode de traitement GPS",
+"gpssatellites" : "Satellites GPS utilisés pour la mesure",
+"gpsspeed" : "Vitesse du récepteur GPS",
+"gpsspeedref" : "Unité de vitesse",
+"km/h" : "Kilomètres par heure",
+"knots" : "Noeuds",
+"mph" : "Miles par heure",
+"gpsstatus" : "État du récepteur GPS",
+"measurementactive" : "Mesure active",
+"measurementvoid" : "Mesure vide",
+"gpstimestamp" : "Heure GPS (horloge atomique)",
+"gpstrack" : "Direction de déplacement",
+"gpstrackref" : "Référence pour la direction de déplacement",
+"gpsversionid" : "Version de tag GPS",
+"gaincontrol" : "Contrôle de gain",
+"highgaindown" : "Forte atténuation",
+"highgainup" : "Fort gain",
+"lowgaindown" : "Faible atténuation",
+"lowgainup" : "Faible gain",
+"gammacompensatedvalue" : "Valeur de compensation gamma",
+"geotiffasciiparams" : "Tag de paramètres Ascii GeoTiff",
+"geotiffdirectory" : "Tag de répertoire de clé GeoTiff",
+"geotiffdoubleparams" : "Tag de paramètres doubles GeoTiff",
+"gradation" : "Luminosite",
+"grayresponsecurve" : "Courbe de réponse du gris",
+"grayresponseunit" : "Unité de réponse en gris",
+"0.0001" : "Le nombre représente des millièmes d\'unité",
+"0.001" : "Le nombre représente des centièmes d\'unité",
+"0.1" : "Le nombre représente des dixièmes d\'unité",
+"1e05" : "Le nombre représente des dix-millièmes d\'unité",
+"1e06" : "Le nombre représente des cent-millièmes d\'unité",
+"graytrc" : "Courbe de reproduction des tons gris",
+"greenmatrixcolumn" : "Colonne de matrice verte",
+"greentrc" : "Courbe de reproduction des tons verts",
+"gripbatteryadload" : "Tension accu poignée en charge",
+"gripbatteryadnoload" : "Tension accu poignée à vide",
+"gripbatterystate" : "État de accu poignée",
+"hcusage" : "Usage HC",
+"hdr" : "HDR auto",
+"halftonehints" : "Indications sur les demi-treintes",
+"headline" : "Titre principal",
+"highisonoisereduction" : "Réduction du bruit en haute sensibilité ISO",
+"weak" : "Faible",
+"weakest" : "La plus faible",
+"highlighttonepriority" : "Priorité hautes lumières",
+"history" : "Récapitulatif",
+"hometowncity" : "Ville de résidence",
+"hometowncitycode" : "Code ville de résidence",
+"hometowndst" : "Heure d\'été de résidence",
+"hostcomputer" : "Ordinateur hôte",
+"hue" : "Nuance",
+"hueadjustment" : "Teinte",
+"hyperfocaldistance" : "Distanace hyperfocale",
+"iccprofilename" : "Nom du profil ICC",
+"icc_profile" : "Profil de couleur ICC d\'entrée",
+"id3size" : "Taille ID3",
+"iptcnaa" : "Métadonnées IPTC-NAA",
+"iptcbitspersample" : "Nombre de bits par échantillon",
+"iptcimageheight" : "Nombre de lignes",
+"iptcimagerotation" : "Rotation d\'image",
+"0" : "Pas de rotation",
+"180" : "Rotation de 180 degrés",
+"270" : "Rotation de 270 degrés",
+"90" : "Rotation de 90 degrés",
+"iptcimagewidth" : "Pixels par ligne",
+"iptcpicturenumber" : "Numéro d\'image",
+"iptcpixelheight" : "Taille de pixel perpendiculairement à la direction de scan",
+"iptcpixelwidth" : "Taille de pixel dans la direction de scan",
+"iso" : "Sensibilité ISO",
+"isoexpansion" : "Extension sensibilité ISO",
+"isofloor" : "Seuil ISO",
+"isoinfo" : "Info ISO",
+"isoselection" : "Choix ISO",
+"isosetting" : "Réglage ISO",
+"isospeedexpansion" : "Extension de sensibilité ISO",
+"isospeedincrements" : "Incréments de sensibilité ISO",
+"isospeedrange" : "Régler l\'extension de sensibilité ISO",
+"it8header" : "En-tête IT8",
+"identifier" : "Identifiant",
+"imageadjustment" : "Ajustement Image",
+"imageareaoffset" : "Décalage de zone d\'image",
+"imageauthentication" : "Authentication de l\'image",
+"imageboundary" : "Cadre Image",
+"imagecolorindicator" : "Indicateur de couleur d\'image",
+"imagecolorvalue" : "Valeur de couleur d\'image",
+"imagecount" : "Compteur d\'images",
+"imagedatasize" : "Taille de l\'image",
+"imagedepth" : "Profondeur d\'image",
+"imagedescription" : "Description d\'image",
+"imageeditcount" : "Compteur de traitement d\'image",
+"imageediting" : "Traitement de l\'image",
+"cropped" : "Recadré",
+"digitalfilter" : "Filtre numérique",
+"framesynthesis?" : "Synthèse de vue ?",
+"imageheight" : "Hauteur d\'image",
+"imagehistory" : "Historique de l\'image",
+"imageid" : "ID d\'image",
+"imagelayer" : "Couche image",
+"imagenumber" : "Numéro d\'image",
+"imageoptimization" : "Optimisation d\'image",
+"imageorientation" : "Orientation d\'image",
+"square" : "Carré",
+"imagesize" : "Taille d\'image",
+"imagesourcedata" : "Données source d\'image",
+"imagestabilization" : "Stabilisation d\'image",
+"on,mode1" : "Enclenché, Mode 1",
+"on,mode2" : "Enclenché, Mode 2",
+"imagetone" : "Ton de l\'image",
+"bright" : "Brillant",
+"imagetype" : "Type d\'image",
+"imageuniqueid" : "Identificateur unique d\'image",
+"imagewidth" : "Largeur d\'image",
+"indexed" : "Indexé",
+"infobuttonwhenshooting" : "Touche INFO au déclenchement",
+"displayscamerasettings" : "Affiche les réglages en cours",
+"displaysshootingfunctions" : "Affiche les fonctions",
+"inknames" : "Nom des encres",
+"inkset" : "Encrage",
+"intellectualgenre" : "Genre intellectuel",
+"cmy(k)devicedependent" : "CMY(K) dépendant de l\'appareil",
+"rgbdevicedependent" : "RVB dépendant de l\'appareil",
+"intergraphmatrix" : "Tag de matrice intergraphe",
+"interlace" : "Entrelacement",
+"internalflashmode" : "Segment de mesure flash esclave 2",
+"didnotfire,(unknown0xf4)" : "Hors service (inconnue 0xF4)",
+"didnotfire,auto" : "Hors service, auto",
+"didnotfire,auto,redeyereduction" : "Hors service, auto, réduction yeux rouges",
+"didnotfire,normal" : "Hors service, normal",
+"didnotfire,redeyereduction" : "Hors service, réduction yeux rouges",
+"didnotfire,slowsync" : "Hors service, synchro lente",
+"didnotfire,slowsync,redeyereduction" : "Hors service, synchro lente, réduction yeux rouges",
+"didnotfire,trailingcurtainsync" : "Hors service, synchro 2e rideau",
+"didnotfire,wireless(control)" : "Hors service, sans cordon (contrôleur)",
+"didnotfire,wireless(master)" : "Hors service, sans cordon (maître)",
+"fired,auto" : "En service, auto",
+"fired,auto,redeyereduction" : "En service, auto, réduction yeux rouges",
+"fired,slowsync" : "En service, synchro lente",
+"fired,slowsync,redeyereduction" : "En service, synchro lente, réduction yeux rouges",
+"fired,trailingcurtainsync" : "En service, synchro 2e rideau",
+"fired,wireless(control)" : "En service, sans cordon (contrôleur)",
+"fired,wireless(master)" : "En service, sans cordon (maître)",
+"internalflashstrength" : "Segment de mesure flash esclave 4",
+"internalserialnumber" : "Numéro de série interne",
+"interopindex" : "Identification d\'interopérabilité",
+"r03dcfoptionfile(adobergb)" : "R03: fichier d\'option DCF (Adobe RGB)",
+"r98dcfbasicfile(srgb)" : "R98: fichier de base DCF (sRGB)",
+"thmdcfthumbnailfile" : "THM: fichier de vignette DCF",
+"interopoffset" : "Indicateur d\'interfonctionnement",
+"interopversion" : "Version d\'interopérabilité",
+"iptclastedited" : "Derniere edition IPTC",
+"jfifversion" : "Version JFIF",
+"jpegactables" : "Tableaux AC JPEG",
+"jpegdctables" : "Tableaux DC JPEG",
+"jpeglosslesspredictors" : "Prédicteurs JPEG sans perte",
+"jpegpointtransforms" : "Transformations de point JPEG",
+"jpegproc" : "Proc JPEG",
+"jpegqtables" : "Tableaux Q JPEG",
+"jpegrestartinterval" : "Intervalle de redémarrage JPEG",
+"jpegtables" : "Tableaux JPEG",
+"jobid" : "ID de la tâche",
+"jpgrecordedpixels" : "Pixels enregistrés JPEG",
+"10mp" : "10 Mpx",
+"2mp" : "2 Mpx",
+"6mp" : "6 Mpx",
+"keyword" : "Mots clé",
+"keywords" : "Mots-clés",
+"lc1" : "Données d\'objectif",
+"lc10" : "Données mv\' nv\'",
+"lc11" : "Données AVC 1/EXP",
+"lc12" : "Données mv1 Avminsif",
+"lc14" : "Données UNT_12 UNT_6",
+"lc15" : "Données d\'adaptation de flash incorporé",
+"lc2" : "Code de distance",
+"lc3" : "Valeur K",
+"lc4" : "Données de correction d\'aberration à courte distance",
+"lc5" : "Données de correction d\'aberration chromatique",
+"lc6" : "Données d\'aberration d\'ouverture",
+"lc7" : "Données de condition minimale de déclenchement AF",
+"lcddisplayatpoweron" : "Etat LCD lors de l\'allumage",
+"display" : "Allumé",
+"retainpoweroffstatus" : "Etat précédent",
+"lcddisplayreturntoshoot" : "Affich. LCD -> Prise de vues",
+"alsowith*etc." : "Aussi par * etc.",
+"withshutterbuttononly" : "Par déclencheur uniq.",
+"lcdilluminationduringbulb" : "Éclairage LCD pendant pose longue",
+"lcdpanels" : "Ecran LCD supérieur/arrière",
+"iso/fileno." : "ISO/No. fichier",
+"iso/remain.shots" : "ISO/Vues restantes",
+"remain.shots/fileno." : "Vues restantes/No. fichier",
+"shotsinfolder/remain.shots" : "Vues dans dossier/Vues restantes",
+"language" : "Langage",
+"languageidentifier" : "Identificateur de langue",
+"leafdata" : "Données Leaf",
+"lens" : "Objectif ",
+"lensafstopbutton" : "Fonct. touche AF objectif",
+"aelockwhilemetering" : "Verr. AE posemètre actif",
+"afstop" : "Arrêt AF",
+"afmode:oneshot<>aiservo" : "Mode AF: ONE SHOT <-> AI SERVO",
+"afpoint:m>auto/auto>ctr." : "Colli: M -> Auto / Auto -> Ctr.",
+"afpoint:m>auto/auto>ctr" : "Collim.AF: M->Auto/Auto->ctr",
+"afstart" : "Activation AF",
+"isstart" : "Activation stab. image",
+"switchtoregisteredafpoint" : "Activer collimateur enregistré",
+"lensdata" : "Valeur K (LC3)",
+"lensdataversion" : "Version des Données Objectif",
+"lensdrivenoaf" : "Pilot. obj. si AF impossible",
+"focussearchoff" : "Pas de recherche du point",
+"focussearchon" : "Recherche du point",
+"lensfstops" : "Nombre de diaphs de l\'objectif",
+"lensid" : "ID Lens",
+"lensidnumber" : "Numéro d\'Objectif",
+"lensinfo" : "Infos lens",
+"lenskind" : "Sorte d\'objectif / version (LC0)",
+"lensserialnumber" : "Numéro de série objectif",
+"lenstype" : "Sorte d\'objectif",
+"lightreading" : "Lecture de la lumière",
+"lightsource" : "Source de lumière",
+"lightvalue" : "Luminosite",
+"lightness" : "Luminosité",
+"linearresponselimit" : "Limite de réponse linéaire",
+"linearizationtable" : "Table de linéarisation",
+"liveviewexposuresimulation" : "Simulation d\'exposition directe",
+"disable(lcdautoadjust)" : "Désactivée (réglge écran auto)",
+"enable(simulatesexposure)" : "Activée (simulation exposition)",
+"localizedcameramodel" : "Nom traduit de modèle d\'appareil",
+"location" : "Ligne",
+"lockmicrophonebutton" : "Fonction de touche microphone",
+"protect(hold:recordmemo)" : "Protéger (maintien: enregistrement sonore)",
+"recordmemo(protect:disable)" : "Enregistrement sonore (protéger: désactivée)",
+"longexposurenoisereduction" : "Réduct. bruit longue expo.",
+"lookuptable" : "Table de correspondance",
+"mcuversion" : "Version MCU",
+"mieversion" : "Version MIE",
+"mimetype" : "Type MIME",
+"macromode" : "Mode Macro",
+"telemacro" : "Macro en télé",
+"magnifiedview" : "Agrandissement en lecture",
+"imageplaybackonly" : "Lecture image uniquement",
+"imagereviewandplayback" : "Aff. inst. et lecture",
+"make" : "Fabricant",
+"makeandmodel" : "Fabricant et modèle",
+"makernote" : "Données privées DNG",
+"makernotesafety" : "Sécurité de note de fabricant",
+"safe" : "Sûre",
+"unsafe" : "Pas sûre",
+"makernoteversion" : "Version des informations spécifiques fabricant",
+"makernotes" : "Notes fabricant",
+"manualfocusdistance" : "Distance de Mise-au-point Manuelle",
+"manualtv" : "Régl. Tv/Av manuel pour exp. M",
+"tv=control/av=main" : "Tv=Contrôle rapide/Av=Principale",
+"tv=control/av=mainw/olens" : "Tv=Contrôle rapide/Av=Principale sans objectif",
+"tv=main/av=control" : "Tv=Principale/Av=Contrôle rapide",
+"tv=main/av=mainw/olens" : "Tv=Principale/Av=Contrôle rapide sans objectif",
+"manufacturedate" : "Date de fabrication",
+"marked" : "Marqué",
+"maskedareas" : "Zones masquées",
+"masterdocumentid" : "ID du document maître",
+"matteing" : "Matité",
+"maxaperture" : "Données Avmin",
+"maxapertureatmaxfocal" : "Ouverture à la focale maxi",
+"maxapertureatminfocal" : "Ouverture à la focale mini",
+"maxaperturevalue" : "Ouverture maximale de l\'objectif",
+"maxavailheight" : "Hauteur max Disponible",
+"maxavailwidth" : "Largeur max Disponible",
+"maxfocallength" : "Focale maxi",
+"maxsamplevalue" : "Valeur maxi d\'échantillon",
+"maxval" : "Valeur max",
+"maximumdensityrange" : "Etendue maximale de densité",
+"measurement" : "Observateur de mesure",
+"measurementbacking" : "Support de mesure",
+"measurementflare" : "Flare de mesure",
+"measurementgeometry" : "Géométrie de mesure",
+"0/45or45/0" : "0/45 ou 45/0",
+"0/dord/0" : "0/d ou d/0",
+"measurementilluminant" : "Illuminant de mesure",
+"measurementobserver" : "Observateur de mesure",
+"mediablackpoint" : "Point noir moyen",
+"mediawhitepoint" : "Point blanc moyen",
+"menubuttondisplayposition" : "Position début touche menu",
+"previous" : "Précédente",
+"previous(topifpoweroff)" : "Précédente (Haut si dés.)",
+"metadatadate" : "Date des metadonnées",
+"meteringmode" : "Mode de mesure",
+"multispot" : "MultiSpot",
+"partial" : "Partielle",
+"spot" : "Grain",
+"meteringmode2" : "Mode de mesure 2",
+"meteringmode3" : "Mode de mesure (3)",
+"minaperture" : "Ouverture mini",
+"minfocallength" : "Focale mini",
+"minsamplevalue" : "Valeur mini d\'échantillon",
+"minoltaquality" : "Qualité",
+"mirrorlockup" : "Verrouillage du miroir",
+"enable:downwithset" : "Activé: Retour par touche SET",
+"moddate" : "Date de modification",
+"model" : "Modèle d\'appareil photo",
+"model2" : "Modèle d\'équipement de prise de vue (2)",
+"modelage" : "Age du modele",
+"modeltiepoint" : "Tag de lien d modèle",
+"modeltransform" : "Tag de transformation de modèle",
+"highest" : "Plus haut",
+"tungsten" : "Tungstène (lumière incandescente)",
+"modifydate" : "Date de modification de fichier",
+"multiexposure" : "Infos Surimpression",
+"multiexposureautogain" : "Auto-expo des surimpressions",
+"multiexposuremode" : "Mode de surimpression",
+"multiexposureshots" : "Nombre de prises de vue",
+"multiexposureversion" : "Version Surimpression",
+"multiframenoisereduction" : "Réduc. bruit multi-photos",
+"multipleexposureset" : "Exposition multiple",
+"name" : "Nom",
+"namedcolor2" : "Couleur nommée 2",
+"nativedigest" : "Sommaire natif",
+"nativedisplayinfo" : "Information sur l\'affichage natif",
+"newsphotoversion" : "Version d\'enregistrement news photo",
+"nickname" : "Surnom",
+"nikoncapturedata" : "Données Nikon Capture",
+"nikoncaptureversion" : "Version Nikon Capture",
+"noise" : "Bruit",
+"noisereduction" : "Réduction du bruit",
+"high(+1)" : "+1 (haut)",
+"highest(+2)" : "+2 (le plus haut)",
+"low(1)" : "-1 (bas)",
+"lowest(2)" : "-2 (le plus bas)",
+"standard" : "",
+"noisereductionapplied" : "Réduction de bruit appliquée",
+"nominalmaxaperture" : "Ouverture maxi nominal",
+"nominalminaperture" : "Ouverture mini nominal",
+"numindexentries" : "Nombre d\'entrées d\'index",
+"numberofinks" : "Nombre d\'encres",
+"oecfcolumns" : "Colonnes OECF",
+"oecfnames" : "Noms OECF",
+"oecfrows" : "Lignes OECF",
+"oecfvalues" : "Valeurs OECF",
+"opiproxy" : "Proxy OPI",
+"objectattributereference" : "Genre intellectuel",
+"objectcycle" : "Cycle d\'objet",
+"bothmorningandevening" : "Les deux",
+"morning" : "Matin",
+"objectname" : "Titre",
+"objectpreviewdata" : "Données de la miniature de l\'objet",
+"objectpreviewfileformat" : "Format de fichier de la miniature de l\'objet",
+"objectpreviewfileversion" : "Version de format de fichier de la miniature de l\'objet",
+"objecttypereference" : "Référence de type d\'objet",
+"offsetschema" : "Schéma de décalage",
+"oldsubfiletype" : "Type du sous-fichier",
+"opticalzoommode" : "Mode Zoom optique",
+"extended" : "Optique EX",
+"optoelectricconvfactor" : "Facteur de conversion optoélectrique",
+"orientation" : "Orientation de l\'image",
+"mirrorhorizontal" : "0° (haut/droit)",
+"mirrorhorizontalandrotate270cw" : "90° sens horaire (gauche/haut)",
+"mirrorhorizontalandrotate90cw" : "90° sens antihoraire (droit/bas)",
+"mirrorvertical" : "180° (bas/gauche)",
+"originalrawfiledata" : "Données du fichier raw d\'origine",
+"originalrawfiledigest" : "Digest du fichier raw original",
+"originalrawfilename" : "Nom du fichier raw d\'origine",
+"originaltransmissionreference" : "Identificateur de tâche",
+"originatingprogram" : "Programme d\'origine",
+"otherimage" : "Autre image",
+"outputresponse" : "Réponse de sortie",
+"owner" : "Proprietaire",
+"ownerid" : "ID du propriétaire",
+"ownername" : "Nom du propriétaire",
+"pdfversion" : "Version PDF",
+"pefversion" : "Version PEF",
+"padding" : "Remplissage",
+"pagename" : "Nom de page",
+"pagenumber" : "Page numéro",
+"panasonicexifversion" : "Version Exif Panasonic",
+"panasonicrawversion" : "Version Panasonic RAW",
+"panasonictitle" : "Titre",
+"pentaximagesize" : "Taille d\'image Pentax",
+"2304x1728or2592x1944" : "2304 x 1728 ou 2592 x 1944",
+"2560x1920or2304x1728" : "2560 x 1920 ou 2304 x 1728",
+"2816x2212or2816x2112" : "2816 x 2212 ou 2816 x 2112",
+"3008x2008or3040x2024" : "3008 x 2008 ou 3040 x 2024",
+"pentaxmodelid" : "Modèle Pentax",
+"pentaxversion" : "Version Pentax",
+"peripherallighting" : "Correction éclairage périphérique",
+"personinimage" : "Personnage sur l\'Image",
+"phasedetectaf" : "Auto-Focus",
+"photometricinterpretation" : "Schéma de pixel",
+"blackiszero" : "Zéro pour noir",
+"colorfilterarray" : "CFA (Matrice de filtre de couleur)",
+"pixarlogl" : "CIE Log2(L) (Log luminance)",
+"pixarlogluv" : "CIE Log2(L)(u\',v\') (Log luminance et chrominance)",
+"rgbpalette" : "Palette RVB",
+"transparencymask" : "Masque de transparence",
+"whiteiszero" : "Zéro pour blanc",
+"photoshopannotations" : "Annotations Photoshop",
+"picturecontrol" : "Optimisation d\'image",
+"picturecontroladjust" : "Ajustement de l\'optimisation d\'image",
+"defaultsettings" : "Paramètres par défault",
+"fullcontrol" : "Réglages manuels",
+"quickadjust" : "Réglages rapides",
+"picturecontrolbase" : "Optimisation d\'image de base",
+"picturecontrolname" : "Nom de l\'optimisation d\'image",
+"picturecontrolquickadjust" : "Optimisation d\'image - Réglages rapides",
+"picturecontrolversion" : "Version de l\'Optimisation d\'image",
+"picturemode" : "Mode d\'image",
+"aperturepriority,offautoaperture" : "Priorité ouverture (auto-diaph hors service)",
+"autopict(landscape)" : "Auto PICT (paysage)",
+"autopict(macro)" : "Auto PICT (macro)",
+"autopict(portrait)" : "Auto PICT (portrait)",
+"autopict(sport)" : "Auto PICT (sport)",
+"autopict(standard)" : "Auto PICT (standard)",
+"autumn" : "Automne",
+"blurreduction" : "Réduction du flou",
+"bulb,offautoaperture" : "Pose B (auto-diaph hors service)",
+"dofprogram(hyp)" : "Programme PdC (Hyper-programme)",
+"darkpet" : "Animal foncé",
+"flashxsyncspeedae" : "Expo auto, vitesse de synchro flash X",
+"food" : "Nourriture",
+"framecomposite" : "Vue composite",
+"greenmode" : "Mode vert",
+"halflengthportrait" : "Portrait (buste)",
+"hispeedprogram(hyp)" : "Programme grande vitesse (Hyper-programme)",
+"lightpet" : "Animal clair",
+"mtfprogram(hyp)" : "Programme FTM (Hyper-programme)",
+"manual,offautoaperture" : "Manuel (auto-diaph hors service)",
+"mediumpet" : "Animal demi-teintes",
+"naturalskintone" : "Ton chair naturel",
+"program" : "Programme",
+"program(hyp)" : "Programme AE (Hyper-programme)",
+"programavshift" : "Décalage programme Av",
+"programtvshift" : "Décalage programme Tv",
+"selfportrait" : "Autoportrait",
+"sensitivitypriorityae" : "Expo auto, priorité sensibilité",
+"shutter&aperturepriorityae" : "Expo auto, priorité vitesse et ouverture",
+"shutterspeedpriority" : "Priorité vitesse",
+"soft" : "Douce",
+"synchrosoundrecord" : "Enregistrement de son synchro",
+"picturemode2" : "Mode d\'image 2",
+"autopict" : "Image auto",
+"scenemode" : "Modes scène",
+"picturestyle" : "Style d\'image",
+"faithful" : "Fidèle",
+"highsaturation" : "Saturation élevée",
+"lowsaturation" : "Faible saturation",
+"pixelintensityrange" : "Intervalle d\'intensité de pixel",
+"pixelscale" : "Tag d\'échelle de pixel modèle",
+"planarconfiguration" : "Arrangement des données image",
+"chunky" : "Format « chunky » (entrelacé)",
+"planar" : "Format « planar »",
+"postalcode" : "Code Postal",
+"powersource" : "Source d\'alimentation",
+"bodybattery" : "Accu boîtier",
+"externalpowersupply" : "Alimentation externe",
+"gripbattery" : "Accu poignée",
+"predictor" : "Prédicteur",
+"horizontaldifferencing" : "Différentiation horizontale",
+"preview0" : "Aperçu 0",
+"preview1" : "Aperçu 1",
+"preview2" : "Aperçu 2",
+"previewapplicationname" : "Nom de l\'application d\'aperçu",
+"previewapplicationversion" : "Version de l\'application d\'aperçu",
+"previewcolorspace" : "Espace de couleur de l\'aperçu",
+"previewdatetime" : "Horodatage d\'aperçu",
+"previewimage" : "Aperçu",
+"previewimageborders" : "Limites d\'image miniature",
+"previewimagedata" : "Données d\'image miniature",
+"previewimagelength" : "Longueur d\'image miniature",
+"previewimagesize" : "Taille d\'image miniature",
+"previewimagestart" : "Début d\'image miniature",
+"previewsettingsdigest" : "Digest des réglages d\'aperçu",
+"previewsettingsname" : "Nom des réglages d\'aperçu",
+"c6(center)" : "C6 (Centre)",
+"primarychromaticities" : "Chromaticité des couleurs primaires",
+"primaryplatform" : "Plateforme primaire",
+"processingsoftware" : "Logiciel de traitement",
+"producer" : "Producteur",
+"productid" : "ID de produit",
+"productioncode" : "L\'appareil est passé en SAV",
+"profilecmmtype" : "Type de profil CMM",
+"profilecalibrationsig" : "Signature de calibration de profil",
+"profileclass" : "Classe de profil",
+"abstractprofile" : "Profil de résumé",
+"colorspaceconversionprofile" : "Profil de conversion d\'espace de couleur",
+"devicelinkprofile" : "Profil de liaison",
+"displaydeviceprofile" : "Profil d\'appareil d\'affichage",
+"inputdeviceprofile" : "Profil d\'appareil d\'entrée",
+"namedcolorprofile" : "Profil de couleur nommée",
+"nikoninputdeviceprofile(nonstandard!)" : "Profil Nikon (\"nkpf\")",
+"outputdeviceprofile" : "Profil d\'appareil de sortie",
+"profileconnectionspace" : "Espace de connexion de profil",
+"profilecopyright" : "Copyright du profil",
+"profilecreator" : "Créateur du profil",
+"profiledatetime" : "Horodatage du profil",
+"profiledescription" : "Description du profil",
+"profiledescriptionml" : "Description de profil ML",
+"profileembedpolicy" : "Règles d\'usage du profil incluses",
+"allowcopying" : "Permet la copie",
+"embedifused" : "Inclus si utilisé",
+"neverembed" : "Jamais inclus",
+"norestrictions" : "Pas de restriction",
+"profilefilesignature" : "Signature de fichier de profil",
+"profilehuesatmapdata1" : "Données de profil teinte sat. 1",
+"profilehuesatmapdata2" : "Données de profil teinte sat. 2",
+"profilehuesatmapdims" : "Divisions de teinte",
+"profileid" : "ID du profil",
+"profilelooktabledata" : "Données de table de correspondance de profil",
+"profilelooktabledims" : "Divisions de teinte",
+"profilename" : "Nom du profil",
+"profilesequencedesc" : "Description de séquence du profil",
+"profiletonecurve" : "Courbe de ton du profil",
+"profileversion" : "Version de profil",
+"programiso" : "Programme ISO",
+"programline" : "Ligne de programme",
+"depth" : "Priorité profondeur de champ",
+"hispeed" : "Priorité grande vitesse",
+"mtf" : "Priorité FTM",
+"programshift" : "Décalage Programme",
+"programversion" : "Version du programme",
+"protect" : "Protéger",
+"provincestate" : "Région / Département",
+"publisher" : "Editeur",
+"quality" : "Qualité",
+"best" : "La meilleure",
+"better" : "Meilleure",
+"compressedraw" : "cRAW",
+"compressedraw+jpeg" : "cRAW+JPEG",
+"extrafine" : "Extra fine",
+"good" : "Bonne",
+"raw+jpeg" : "RAW+JPEG",
+"qualitymode" : "Qualité",
+"fine" : "Haute",
+"quantizationmethod" : "Méthode de quantification",
+"colorspacespecific" : "Spécifique à l\'espace de couleur",
+"compressionmethodspecific" : "Spécifique à la méthode de compression",
+"gammacompensated" : "Compensée gamma",
+"iptcrefb" : "IPTC réf \"B\"",
+"lineardensity" : "Densité linéaire",
+"lineardotpercent" : "Pourcentage de point linéaire",
+"linearreflectance/transmittance" : "Réflectance/transmittance linéaire",
+"quickcontroldialinmeter" : "Molette de contrôle rapide en mesure",
+"exposurecomp/aperture" : "Correction exposition/ouverture",
+"isospeed" : "Sensibilité ISO",
+"rafversion" : "Version RAF",
+"rasterpadding" : "Remplissage raster",
+"rasterizedcaption" : "Titre rastérisé",
+"rating" : "Évaluation",
+"ratingpercent" : "Rapport en pourcentage",
+"rawandjpgrecording" : "Enregistrement RAW et JPEG",
+"jpeg(best)" : "JPEG (le meilleur)",
+"jpeg(better)" : "JPEG (meilleur)",
+"jpeg(good)" : "JPEG (bon)",
+"raw(dng,best)" : "RAW (DNG, le meilleur)",
+"raw(dng,better)" : "RAW (DNG, meilleur)",
+"raw(dng,good)" : "RAW (DNG, bon)",
+"raw(pef,best)" : "RAW (PEF, le meilleur)",
+"raw(pef,better)" : "RAW (PEF, meilleur)",
+"raw(pef,good)" : "RAW (PEF, bon)",
+"raw+jpeg(dng,best)" : "RAW+JPEG (DNG, le meilleur)",
+"raw+jpeg(dng,better)" : "RAW+JPEG (DNG, meilleur)",
+"raw+jpeg(dng,good)" : "RAW+JPEG (DNG, bon)",
+"raw+jpeg(pef,best)" : "RAW+JPEG (PEF, le meilleur)",
+"raw+jpeg(pef,better)" : "RAW+JPEG (PEF, meilleur)",
+"raw+jpeg(pef,good)" : "RAW+JPEG (PEF, bon)",
+"raw+large/fine" : "RAW+grande/fine",
+"raw+large/normal" : "RAW+grande/normale",
+"raw+medium/fine" : "RAW+moyenne/fine",
+"raw+medium/normal" : "RAW+moyenne/normale",
+"raw+small/fine" : "RAW+petite/fine",
+"raw+small/normal" : "RAW+petite/normale",
+"rawdataoffset" : "Décalage données Raw",
+"rawdatauniqueid" : "ID unique de données brutes",
+"rawimagecenter" : "Centre Image RAW",
+"rawimagedigest" : "Digest d\'image brute",
+"rawimagesize" : "Taille d\'image RAW",
+"recordmode" : "Mode d\'enregistrement",
+"redbalance" : "Balance rouge",
+"redmatrixcolumn" : "Colonne de matrice rouge",
+"redtrc" : "Courbe de reproduction des tons rouges",
+"reductionmatrix1" : "Matrice de réduction 1",
+"reductionmatrix2" : "Matrice de réduction 2",
+"referenceblackwhite" : "Paire de valeurs de référence noir et blanc",
+"referencedate" : "Date de référence",
+"referencenumber" : "Numéro de référence",
+"referenceservice" : "Service de référence",
+"relatedimagefileformat" : "Format de fichier image apparenté",
+"relatedimageheight" : "Hauteur d\'image apparentée",
+"relatedimagewidth" : "Largeur d\'image apparentée",
+"relatedsoundfile" : "Fichier audio apparenté",
+"releasedate" : "Date de version",
+"releasetime" : "Heure de version",
+"renderingintent" : "Intention de rendu",
+"iccabsolutecolorimetric" : "Colorimétrique absolu",
+"mediarelativecolorimetric" : "Colorimétrique relatif",
+"perceptual" : "Perceptif",
+"resolution" : "Résolution d\'image",
+"resolutionunit" : "Unité de résolution en X et Y",
+"cm" : "Pixels/cm",
+"retouchhistory" : "Historique retouche",
+"revisionnumber" : "Numéro de révision",
+"rights" : "Droits",
+"rowinterleavefactor" : "Facteur d\'entrelacement des lignes",
+"rowsperstrip" : "Nombre de rangées par bande",
+"smaxsamplevalue" : "Valeur maxi d\'échantillon S",
+"sminsamplevalue" : "Valeur mini d\'échantillon S",
+"spiffversion" : "Version SPIFF",
+"sractive" : "Réduction de bougé active",
+"srfocallength" : "Focale de réduction de bougé",
+"srhalfpresstime" : "Temps entre mesure et déclenchement",
+"srresult" : "Stabilisation",
+"notstabilized" : "Non stabilisé",
+"svgversion" : "Version SVG",
+"safetyshift" : "Décalage de sécurité",
+"enable(isospeed)" : "Activé (sensibilité ISO)",
+"enable(tv/av)" : "Activé (Tv/Av)",
+"safetyshiftinavortv" : "Décalage de sécurité Av ou Tv",
+"sampleformat" : "Format d\'échantillon",
+"complexint" : "Entier complexe",
+"float" : "Réel à virgule flottante",
+"signed" : "Entier signé",
+"undefined" : "Non défini",
+"unsigned" : "Entier non signé",
+"samplestructure" : "Structure d\'échantillonnage",
+"compressiondependent" : "Définie dans le processus de compression",
+"orthogonal422sampling" : "Orthogonale, avec les fréquences d\'échantillonnage dans le rapport 4:2:2:(4)",
+"orthogonalconstangsampling" : "Orthogonale, avec les mêmes fréquences d\'échantillonnage relatives sur chaque composante",
+"samplesperpixel" : "Nombre de composantes",
+"scanningdirection" : "Direction de scannage",
+"bottomtop,lr" : "De bas en haut, de gauche à droite",
+"bottomtop,rl" : "De bas en haut, de droite à gauche",
+"lr,bottomtop" : "De gauche à droite, de bas en haut",
+"lr,topbottom" : "De gauche à droite, de haut en bas",
+"rl,bottomtop" : "De droite à gauche, de bas en haut",
+"rl,topbottom" : "De droite à gauche, de haut en bas",
+"topbottom,lr" : "De haut en bas, de gauche à droite",
+"topbottom,rl" : "De haut en bas, de droite à gauche",
+"scene" : "Scène",
+"sceneassist" : "Assistant Scene",
+"scenecapturetype" : "Type de capture de scène",
+"3dsweeppanorama" : "3D",
+"antimotionblur" : "Anti-flou de mvt",
+"cont.priorityae" : "AE priorité continue",
+"handheldnightshot" : "Vue de nuit manuelle",
+"nightportrait" : "Portrait de nuit",
+"sweeppanorama" : "Panora. par balayage",
+"scenetype" : "Type de scène",
+"directlyphotographed" : "Image photographiée directement",
+"securityclassification" : "Classement de sécurité",
+"confidential" : "Confidentiel",
+"restricted" : "Restreint",
+"topsecret" : "Top secret",
+"unclassified" : "Non classé",
+"selectableafpoint" : "Collimateurs AF sélectionnables",
+"11points" : "11 collimateurs",
+"19points" : "19 collimateurs",
+"45points" : "45 collimateurs",
+"inner9points" : "9 collimateurs centraux",
+"outer9points" : "9 collimateurs périphériques",
+"selftimer" : "Retardateur",
+"selftimer2" : "Retardateur (2)",
+"selftimermode" : "Mode auto-timer",
+"sensingmethod" : "Méthode de capture",
+"colorsequentialarea" : "Capteur couleur séquentiel",
+"colorsequentiallinear" : "Capteur couleur séquentiel linéaire",
+"monochromearea" : "Capteur monochrome",
+"monochromelinear" : "Capteur linéaire monochrome",
+"onechipcolorarea" : "Capteur monochip couleur",
+"threechipcolorarea" : "Capteur trois chips couleur",
+"trilinear" : "Capteur trilinéaire",
+"twochipcolorarea" : "Capteur deux chips couleur",
+"sensitivityadjust" : "Réglage de sensibilité",
+"sensitivitysteps" : "Pas de sensibilité",
+"1evsteps" : "Pas de 1 IL",
+"asevsteps" : "Comme pas IL",
+"sensorheight" : "Hauteur du capteur",
+"sensorpixelsize" : "Taille des pixels du capteur",
+"sensorwidth" : "Largeur du capteur",
+"sequencenumber" : "Numéro de Séquence",
+"serialnumber" : "Numéro de série",
+"serviceidentifier" : "Identificateur de service",
+"setbuttoncrosskeysfunc" : "Réglage touche SET/joypad",
+"crosskeys:afpointselect" : "Joypad:Sélec. collim. AF",
+"set:flashexposurecomp" : "SET:Cor expo flash",
+"set:parameter" : "SET:Changer de paramètres",
+"set:picturestyle" : "SET:Style d’image",
+"set:playback" : "SET:Lecture",
+"set:quality" : "SET:Qualité",
+"setbuttonwhenshooting" : "Touche SET au déclenchement",
+"changeparameters" : "Changer de paramètres",
+"default(nofunction)" : "Normal (désactivée)",
+"disabled" : "Désactivée",
+"flashexposurecompensation" : "Correction expo flash",
+"imageplayback" : "Lecture de l\'image",
+"lcdmonitoron/off" : "Écran LCD On/Off",
+"menudisplay" : "Affichage du menu",
+"normal(disabled)" : "Normal (désactivée)",
+"quickcontrolscreen" : "Écran de contrôle rapide",
+"recordfunc.+media/folder" : "Fonction enregistrement + média/dossier",
+"recordmovie(liveview)" : "Enr. vidéo (visée écran)",
+"whitebalance" : "Balance des blancs",
+"setfunctionwhenshooting" : "Touche SET au déclenchement",
+"changepicturestyle" : "Style d\'image",
+"changequality" : "Changer de qualité",
+"imagereplay" : "Lecture de l\'image",
+"shadingcompensation" : "Compensation de l\'ombrage",
+"shadowscale" : "Echelle d\'ombre",
+"shakereduction" : "Réduction du bougé (réglage)",
+"shakereductioninfo" : "Stabilisation",
+"sharpness" : "Accentuation",
+"hard" : "Dure",
+"medhard" : "Assez dure",
+"medsoft" : "Assez douce",
+"veryhard" : "Très dure",
+"verysoft" : "Très douce",
+"shootingmode" : "Télécommande IR",
+"aerialphoto" : "Photo aérienne",
+"baby" : "Bébé",
+"coloreffects" : "Effets de couleurs",
+"highsensitivity" : "Haute sensibilité",
+"highspeedcontinuousshooting" : "Déclenchement continu à grande vitesse",
+"intelligentauto" : "Mode Auto intelligent",
+"intelligentiso" : "ISO Intelligent",
+"moviepreview" : "Prévisualisation vidéo",
+"panning" : "Panoramique",
+"panoramaassist" : "Assistant Panorama",
+"party" : "Fête",
+"scenery" : "Paysage",
+"softskin" : "Peau douce",
+"starrynight" : "Nuit étoilée",
+"shortdocumentid" : "ID court de document",
+"shortreleasetimelag" : "Intertie au déclenchement réduite",
+"shotinfoversion" : "Version des Infos prise de vue",
+"shutteraelock" : "Déclencheur/Touche verr. AE",
+"aelock/af" : "Verrouillage AE/Autofocus",
+"ae/af,noaelock" : "AE/AF, pad de verrou. AE",
+"af/aelock" : "Autofocus/verrouillage AE",
+"af/aflock" : "Autofocus/verrouillage AF",
+"af/aflock,noaelock" : "AF/ver.AF, pad de verr.AE",
+"shutteraelbutton" : "Déclencheur/Touche verr. AE",
+"af/aelockstop" : "Autofocus/Verrouillage AE",
+"shutterbuttonafonbutton" : "Déclencheur/Touche AF",
+"aelock/metering+afstart" : "Mémo expo/lct. mesure+AF",
+"metering+afstart" : "Mesure + lancement AF",
+"metering+afstart/afstop" : "Mesure + lancement/arrêt AF",
+"metering+afstart/disable" : "Lct. mesure+AF/désactivée",
+"meteringstart/meter+afstart" : "Lct. mesure/lct. mesure+AF",
+"shuttercount" : "Comptage des déclenchements",
+"shuttercurtainsync" : "Synchronisation du rideau",
+"1stcurtainsync" : "Synchronisation premier rideau",
+"2ndcurtainsync" : "Synchronisation deuxième rideau",
+"shutterreleasenocfcard" : "Déclench. obtur. sans carte",
+"shutterspeed" : "Temps de pose",
+"shutterspeedrange" : "Régler gamme de vitesses",
+"shutterspeedvalue" : "Vitesse d\'obturation",
+"sidecarforextension" : "Extension",
+"similarityindex" : "Indice de similarité",
+"slaveflashmeteringsegments" : "Segments de mesure flash esclave",
+"slowshutter" : "Vitesse d\'obturation lente",
+"software" : "Logiciel",
+"spatialfrequencyresponse" : "Réponse spatiale en fréquence",
+"spectralsensitivity" : "Sensibilité spectrale",
+"spotmeterlinktoafpoint" : "Mesure spot liée au collimateur AF",
+"disable(usecenterafpoint)" : "Désactivée (utiliser collimateur AF central)",
+"enable(useactiveafpoint)" : "Activé (utiliser collimateur AF actif)",
+"state" : "Etat",
+"stripbytecounts" : "Octets par bande compressée",
+"stripoffsets" : "Emplacement des données image",
+"sublocation" : "Lieu",
+"subseccreatedate" : "Date de la création des données numériques",
+"subsecdatetimeoriginal" : "Date de la création des données originales",
+"subsecmodifydate" : "Date de modification de fichier",
+"subsectime" : "Fractions de seconde de DateTime",
+"subsectimedigitized" : "Fractions de seconde de DateTimeDigitized",
+"subsectimeoriginal" : "Fractions de seconde de DateTimeOriginal",
+"subtileblocksize" : "Taille de bloc de sous-tuile",
+"subfiletype" : "Type du nouveau sous-fichier",
+"subject" : "Sujet",
+"subjectarea" : "Zone du sujet",
+"subjectcode" : "Code sujet",
+"subjectdistance" : "Distance du sujet",
+"subjectdistancerange" : "Intervalle de distance du sujet",
+"close" : "Vue rapprochée",
+"distant" : "Vue distante",
+"subjectlocation" : "Zone du sujet",
+"subjectreference" : "Code de sujet",
+"superimposeddisplay" : "Affichage superposé",
+"supplementalcategories" : "Catégorie d\'appoint",
+"supplementaltype" : "Type de supplément",
+"mainimage" : "Non établi",
+"reducedresolutionimage" : "Image de résolution réduite",
+"svisosetting" : "Réglage ISO Sv",
+"assist" : "Touche d\'assistance",
+"assist+af" : "Touche d\'assistance + touche AF",
+"onlywhilepressingassist" : "Seulement en appuyant touche d\'assistance",
+"t4options" : "Bits de remplissage ajoutés",
+"t6options" : "Options T6",
+"ttl_da_adown" : "Segment de mesure flash esclave 6",
+"ttl_da_aup" : "Segment de mesure flash esclave 5",
+"ttl_da_bdown" : "Segment de mesure flash esclave 8",
+"ttl_da_bup" : "Segment de mesure flash esclave 7",
+"targetprinter" : "Imprimantte cible",
+"technology" : "Technologie",
+"activematrixdisplay" : "Afficheur à matrice active",
+"cathoderaytubedisplay" : "Afficheur à tube cathodique",
+"dyesublimationprinter" : "Imprimante à sublimation thermique",
+"electrophotographicprinter" : "Imprimante électrophotographique",
+"electrostaticprinter" : "Imprimante électrostatique",
+"flexography" : "Flexographie",
+"inkjetprinter" : "Imprimante à jet d\'encre",
+"offsetlithography" : "Lithographie offset",
+"passivematrixdisplay" : "Afficheur à matrice passive",
+"photocd" : "CD photo",
+"photoimagesetter" : "Cadre photo",
+"photographicpaperprinter" : "Imprimante à papier photo",
+"projectiontelevision" : "Téléviseur à projection",
+"reflectivescanner" : "Scanner à réflexion",
+"silkscreen" : "Ecran de soie",
+"thermalwaxprinter" : "Imprimante thermique à cire",
+"videocamera" : "Caméra vidéo",
+"videomonitor" : "Moniteur vidéo",
+"thresholding" : "Seuil",
+"thumbnailheight" : "Hauteur de la vignette",
+"thumbnailimage" : "Vignette",
+"thumbnailimagesize" : "Taille des miniatures",
+"thumbnailwidth" : "Hauteur de la vignette",
+"tilebytecounts" : "Nombre d\'octets d\'élément",
+"tiledepth" : "Profondeur d\'élément",
+"tilelength" : "Longueur d\'élément",
+"tileoffsets" : "Décalages d\'élément",
+"tilewidth" : "Largeur d\'élément",
+"time" : "Heure",
+"timecreated" : "Heure de création",
+"timesent" : "Heure d\'envoi",
+"timesincepoweron" : "Temps écoulé depuis la mise en marche",
+"timezoneoffset" : "Offset de zone de date",
+"timerlength" : "Durée du retardateur",
+"title" : "Titre",
+"tonecomp" : "Correction de tonalité",
+"tonecurve" : "Courbe de ton",
+"tonecurves" : "Courbes de ton",
+"toningeffect" : "Virage",
+"toningsaturation" : "Saturation du virage",
+"transferfunction" : "Fonction de transfert",
+"transferrange" : "Intervalle de transfert",
+"transmissionreference" : "Référence transmission",
+"transparencyindicator" : "Indicateur de transparence",
+"trapindicator" : "Indicateur de piège",
+"trapped" : "Piégé",
+"false" : "Faux",
+"true" : "Vrai",
+"travelday" : "Date du Voyage",
+"tvexposuretimesetting" : "Réglage de temps de pose Tv",
+"url" : "URL ",
+"usmlenselectronicmf" : "MF électronique à objectif USM",
+"alwaysturnedoff" : "Toujours débrayé",
+"disableafteroneshotaf" : "Désactivée après One-Shot AF",
+"disableinafmode" : "Désactivée en mode AF",
+"enableafteroneshotaf" : "Activée après AF One-Shot",
+"turnsoffafteroneshotaf" : "Débrayé aprés One-Shot AF",
+"turnsonafteroneshotaf" : "Activé aprés One-Shot AF",
+"uniquecameramodel" : "Nom unique de modèle d\'appareil",
+"uniquedocumentid" : "ID unique de document",
+"uniqueobjectname" : "Nom Unique d\'Objet",
+"urgency" : "Urgence",
+"usablemeteringmodes" : "Sélectionner modes de mesure",
+"usableshootingmodes" : "Sélectionner modes de prise de vue",
+"usageterms" : "Conditions d\'Utilisation",
+"usercomment" : "Commentaire utilisateur",
+"vrdversion" : "Version VRD",
+"vrinfo" : "Information stabilisateur",
+"vrinfoversion" : "Info Version VR",
+"variprogram" : "Variprogramme",
+"vibrationreduction" : "Reduction des vibrations",
+"videocardgamma" : "Gamma de la carte vidéo",
+"viewinfoduringexposure" : "Infos viseur pendant exposition",
+"viewingconddesc" : "Description des conditions de visionnage",
+"viewingcondilluminant" : "Illuminant des conditions de visionnage",
+"viewingcondilluminanttype" : "Type d\'illuminant des conditions de visionnage",
+"viewingcondsurround" : "Environnement des conditions de visionnage",
+"vignettecontrol" : "Controle du vignettage",
+"wbadjustab" : "Ajustement Balance des Blancs bleu/jaune",
+"wbadjustgm" : "Ajustement Balance des Blancs vert/magenta",
+"wbbluelevel" : "Niveau Bleu Balance des Blancs",
+"wbgreenlevel" : "Niveau Vert Balance des Blancs",
+"wbmediaimagesizesetting" : "Réglage de balance des blancs + taille d\'image",
+"lcdmonitor" : "Écran LCD",
+"rearlcdpanel" : "Panneau LCD arrièr",
+"wbredlevel" : "Niveau Rouge Balance des Blancs",
+"wbshiftab" : "Décalage bal. blancs ambre-bleu",
+"wbshiftgm" : "Décalage bal. blancs vert-magenta",
+"wbshiftmg" : "Décalage bal. blancs magenta-vert",
+"wb_gbrglevels" : "Niveaux BB VBRV",
+"wb_grbglevels" : "Niveaux BB VRBV",
+"wb_grgblevels" : "Niveaux BB VRVB",
+"wb_rbgglevels" : "Niveaux BB RBVV",
+"wb_rblevels" : "Niveaux BB RB",
+"wb_rblevels3000k" : "Niveaux BB RB 3000K",
+"wb_rblevels3300k" : "Niveaux BB RB 3300K",
+"wb_rblevels3600k" : "Niveaux BB RB 3600K",
+"wb_rblevels3900k" : "Niveaux BB RB 3800K",
+"wb_rblevels4000k" : "Niveaux BB RB 4000K",
+"wb_rblevels4300k" : "Niveaux BB RB 4300K",
+"wb_rblevels4500k" : "Niveaux BB RB 4500K",
+"wb_rblevels4800k" : "Niveaux BB RB 4800K",
+"wb_rblevels5300k" : "Niveaux BB RB 5300K",
+"wb_rblevels6000k" : "Niveaux BB RB 6000K",
+"wb_rblevels6600k" : "Niveaux BB RB 6600K",
+"wb_rblevels7500k" : "Niveaux BB RB 7500K",
+"wb_rblevelscloudy" : "Niveaux BB RB nuageux",
+"wb_rblevelsshade" : "Niveaux BB RB ombre",
+"wb_rblevelstungsten" : "Niveaux BB RB tungstène",
+"wb_rgbglevels" : "Niveaux BB RVBV",
+"wb_rgblevels" : "Niveaux BB RVB",
+"wb_rgblevelscloudy" : "Niveaux BB RVB nuageux",
+"wb_rgblevelsdaylight" : "Niveaux BB RVB lumière jour",
+"wb_rgblevelsflash" : "Niveaux BB RVB flash",
+"wb_rgblevelsfluorescent" : "Niveaux BB RVB fluorescent",
+"wb_rgblevelsshade" : "Niveaux BB RVB ombre",
+"wb_rgblevelstungsten" : "Niveaux BB RVB tungstène",
+"wb_rggblevels" : "Niveaux BB RVVB",
+"wb_rggblevelscloudy" : "Niveaux BB RVVB nuageux",
+"wb_rggblevelsdaylight" : "Niveaux BB RVVB lumière jour",
+"wb_rggblevelsflash" : "Niveaux BB RVVB flash",
+"wb_rggblevelsfluorescent" : "Niveaux BB RVVB fluorescent",
+"wb_rggblevelsfluorescentd" : "Niveaux BB RVVB fluorescent",
+"wb_rggblevelsfluorescentn" : "Niveaux BB RVVB fluo N",
+"wb_rggblevelsfluorescentw" : "Niveaux BB RVVB fluo W",
+"wb_rggblevelsshade" : "Niveaux BB RVVB ombre",
+"wb_rggblevelstungsten" : "Niveaux BB RVVB tungstène",
+"wcsprofiles" : "Profil Windows Color System",
+"warning" : "Attention",
+"webstatement" : "Relevé Web",
+"colortemperature/colorfilter" : "Temp.Couleur / Filtre couleur",
+"custom1" : "Personnalisée 1",
+"custom2" : "Personnalisée 2",
+"custom3" : "Personnalisée 3",
+"custom4" : "Personnalisée 4",
+"manualtemperature(kelvin)" : "Température de couleur (Kelvin)",
+"userselected" : "Sélectionnée par l\'utilisateur",
+"whitebalancebias" : "Décalage de Balance des blancs",
+"whitebalancefinetune" : "Balance des blancs - Réglage fin",
+"whitebalancemode" : "Mode de balance des blancs",
+"auto(cloudy)" : "Auto (nuageux)",
+"auto(daywhitefluorescent)" : "Auto (fluo jour)",
+"auto(daylightfluorescent)" : "Auto (fluo lum. jour)",
+"auto(daylight)" : "Auto (lumière du jour)",
+"auto(flash)" : "Auto (flash)",
+"auto(shade)" : "Auto (ombre)",
+"auto(tungsten)" : "Auto (tungstène)",
+"auto(whitefluorescent)" : "Auto (fluo blanc)",
+"whitebalanceset" : "Réglage de balance des blancs",
+"setcolortemperature1" : "Température de couleur définie 1",
+"setcolortemperature2" : "Température de couleur définie 2",
+"setcolortemperature3" : "Température de couleur définie 3",
+"whitelevel" : "Niveau blanc",
+"whitepoint" : "Chromaticité du point blanc",
+"worldtime" : "Fuseau horaire",
+"worldtimelocation" : "Position en temps mondial",
+"home" : "Départ",
+"hometown" : "Résidence",
+"writereditor" : "Auteur de la légende / Description",
+"xclippathunits" : "Unités de chemin de rognage en X",
+"xmp" : "Métadonnées XMP",
+"xpauthor" : "Auteur",
+"xpcomment" : "Commentaire",
+"xpkeywords" : "Mots clé",
+"xpsubject" : "Sujet",
+"xptitle" : "Titre",
+"xposition" : "Position en X",
+"xresolution" : "Résolution d\'image horizontale",
+"ycbcrcoefficients" : "Coefficients de la matrice de transformation de l\'espace de couleurs",
+"ycbcrpositioning" : "Positionnement Y et C",
+"centered" : "Centré",
+"cosited" : "Côte à côte",
+"ycbcrsubsampling" : "Rapport de sous-échantillonnage Y à C",
+"yclippathunits" : "Unités de chemin de rognage en Y",
+"yposition" : "Position en Y",
+"yresolution" : "Résolution d\'image verticale",
+"year" : "Année",
+"zonematching" : "Ajustage de la zone",
+"highkey" : "Hi",
+"isosettingused" : "Désactivée",
+"lowkey" : "Lo",
+};

 /trunk/war/i18n/messages_en.js
 New file
 ,0 → 1,403
+var messages_en = {
+                "intitule-langue" : "English",
+                "cel-utilisation" : "Use the Carnet En Ligne to manage your observations",
+                "identifiez-vous" : "log-in",
+                "pour-transmettre-tela" : "to transmit them to the Tela Botanica network",
+                "connecte-en-tant-que" : "Logged in as {0}",
+                "deconnexion" : "logout",
+                "langue" : "Language",
+                "import-erreurs" : "Warning ! Some errors occured during import : {0}",
+                "import-obs-ajoutees" : "{0} observation(s) added",
+                "import-images-ajoutees" :  "{0} image(s) linked",
+                "import-mots-cles-ajoutes" : "{0} keywords added",
+                "import-colonnes-non-traitees" : "Unrecognized columns : {0}",
+                "envoyer" : "Send",
+                "filtres" : "Filters",
+                "dates" : "Dates",
+                "inconnue" : "Unknown",
+                "recherche-libre" : "Free search",
+                "rechercher" : "Search",
+                "afficher-images-tampon" : "Show images in the buffer only",
+                "ajouter-images" : "Add images",
+                "tampon" : "Buffer",
+                "gerer-mots-cles" : "Manage keywords",
+                "mots-cles" : "keywords",
+                "mots-cles-arbre" : "Keywords",
+                "appliquer" : "Apply",
+                "annuler" : "Cancel",
+                "nouveau-tag" : "New Tag",
+                "renommer" : "Rename",
+                "supprimer" : "Delete",
+                "localites" : "Locations",
+                "projets" : "Projects",
+                "ajouter-projet" : "Add a project",
+                "supprimer-projet" : "Delete project",
+                "mot-cle-non-vide" : "A keyword may not be empty nor contain one of the following characters : {0}",
+                "mot-cle-existe-deja" : "A keyword with the same name already exists at the same position",
+                "confirmer-suppression-projet" : "Are you sure you want to delete this project ?",
+                "impossible-supprimer-racine" : "Cannot delete tree root",
+                "aucune-image-taxon" : "No image for this taxon",
+                "aucune-carte-taxon" : "No map for this taxon",
+                "aucune-image-liee" : "No image linked",
+                "plusieurs-fichiers-images-fois" : "Multiple files at once",
+                "un-fichier-image-fois" : "One file at a time",
+                "ajouter-images-tampon" :  "Add selected images to the buffer",
+                "vider-tampon" : "Delete buffer content",
+                "afficher-tampon" : "Show buffer content",
+                "indication-utilisation-tampon" : "With the buffer, you can pick and show images from differents pages",
+                "indication-supprimer-images" : "Delete selected images",
+                "indication-plusieurs-fichiers-images-fois" : "Add images by selecting them one by one or by uploading a whole folder at once",
+                "galerie" : "Gallery",
+                "images" : "Images",
+                "avertissement-aucune-image" : "No image to display",
+                "cliquez-plusieurs-fichiers-images-fois" : "Click here to upload a whole folder or multiple files at once",
+                "necessite-java" : "requires Java",
+                "cliquez-un-fichier-image-fois" : "Click here to add files one at a time",
+                "indication-ajouter-images-plus-tard" : "To add images later click the Add images button on the top bar",
+                "agrandissement" : "enlargement",
+                "double-clic-agrandir" : "Double click to enlarge image",
+                "voir-fiche-eflore" : "See eFlore page",
+                "numero" : "Number",
+                "date" : "Date",
+                "lieu" : "Location",
+                "appareil" : "Device",
+                "image" : "Image",
+                "note" : "Note",
+                "nom-original" : "Original name",
+                "nom-associe" : "Associated name",
+                "glissez-deposer-images-obs" : "Drag and drop images on the observations list to link them",
+                "changer-utilisateur" : "Change user",
+                "lier-images-selection-obs" : "Link selected images to selected observations",
+                "lier-tampon-selection-obs" : "Link buffer to selected observations",
+                "supprimer-liaison" : "Delete link",
+                "images-liees" : "Linked images",
+                "taxon" : "Taxon",
+                "observations" : "Observations",
+                "obs" : "Obs",
+                "toutes-observations" : "All observations",
+                "observations-liees" :  "Linked observations",
+                "glissez-deposer-obs-images" : "Drag and drop the observation on an image or an image selection to link them",
+                "chargement" : "Loading",
+                "lier-images-selectionnes" : "Link to selected images",
+                "infos-generales" : "Infos",
+                "infos-exif" : "Exif",
+                "infos-iptc" : "Iptc",
+                "infos" : "Infos",
+                "commentaires" : "Comments",
+                "ok" : "ok",
+                "recherche-dans-observations" : "Search in observations",
+                "exif-metadonnees" : "Exif metadata",
+                "iptc-metadonnees" : "IPTC metadata",
+                "indication-zoom-retour-vue-precedente" : "Double click to go back to the previous view, use the mouse wheel or the arrows to navigate between images",
+                "mode-zoom" : "Zoom mode",
+                "choisir-utilisateur" : "Choose user",
+                "utilisateurs" : "Users",
+                "en-recherche" : "Searching",
+                "adresser-remarque-probleme" : "Send us your remarks or report a problem",
+                "admin-consulter-donnees" : "You are currently viewing the observations of {0}",
+                "question-import-anonyme-connecte" : "Do you want to import your anonymous observations into your connected account",
+                "import-observations" : "Observations import",
+                "enoyer" : "send",
+                "telecharger-modele" : "Download a document template",
+                "import-standard" : "for standard import",
+                "import-champs-projets" : "for the project {0}",
+                "importer" : "Import",
+                "exporter" : "Export",
+                "export-nc-ce-bf-bv" : "Export common names, extended fields, Baseflor data and Baseveg syntaxons",
+                "export-etendu" : "Extended export",
+                "etiquettes-pdf" : "Generate labels in PDF format for the current selection",
+                "etiquettes" : "Labels",
+                "transmis" : "Transmitted",
+                "glissez-observations-pour-lier" : "Drag the selected observations onto a projet to link them to it",
+                "referentiel" : "Référentiel",
+                "nom-saisi" : "Typed name",
+                "nom-retenu" : "Accepted name",
+                "famille" : "Family",
+                "altitude-court" : "alt",
+                "abondance" : "Abundancy",
+                "phenologie" : "Phenology",
+                "ordre" : "Order",
+                "details-images-obs" : "Details and observations",
+                "liste" : "List",
+                "question-envoi-images-identifie" : "You need to be logged in to upload images. Do you want to log in now ?",
+                "message-suppression-images-impossible" : "Deletion error : no image selected",
+                "ajouter-mot-cle" : "Add keyword",
+                "renommer-mot-cle" : "Rename keyword",
+                "supprimer-mot-cle" : "Delete keyword",
+                "nb-images-ajoutees-tampon" : "{0} image(s) added to buffer",
+                "contenu-tampon" : "Buffer content",
+                "question-lier-images-obs-sel" : "Link selected images to selected observation (this will replace previous links) ?",
+                "question-lier-obs-image-point" : "Link selected observations to the image under the cursor (this will replace previous links)",
+                "question-lier-obs-images-sel" : "Link selected observations to selected images (this will replace previous links)",
+                "question-lier-obs-sel-images-sel" : "Link selected images to selected observations (this will replace previous links)",
+                "tampon-vide" : "The buffer is empty",
+                "tampon-a-ete-vide" : "The buffer has been emptied",
+                "aucune-obs-selectionnee" : "No observation selected",
+                "aucune-image-selectionnee" : "No image selected",
+                "question-supprimer-lien-images-obs" : "Delete link between images and observations",
+                "page" : "Page",
+                "sur" : "out of",
+                "afficher" : "Show",
+                "elements" : "Elements",
+                "par-page" : "by page",
+                "aide" : "Help",
+                "remarques" : "Remarks",
+                "bugs-remarques" : "Bugs, remarks",
+                "connexion" : "Log in",
+                "mail" : "Mail",
+                "mail-vide-incorrect" : "Mail is incorrect or empty",
+                "mot-de-passe" : "Password",
+                "mot-de-passe-vide-incorrect" : "Password is incorrect or empty",
+                "identifiant-mot-de-passe-invalide" : "Incorrect login/password",
+                "valider" : "Accept",
+                "refuser" : "Decline",
+                "acceptation-licence" : "CEL licence agreement",
+                "lu-accepte-licence" : "I have read and accepted the licence agreement",
+                "tags" : "Tags",
+                "impossible-supprimer-racine" : "You can't delete the tree's root",
+                "identification" : "Identification",
+                "probleme-mise-a-jour-donnees" : "An error has occured while updating the data",
+                "mots-cles-appliques" : "The following keywords have been applied",
+                "erreur-contacter-serveur" : "Cannot reach the server, please check the CEL's configuration or contact an administrator",
+                "mot-cle-supprime" : "Keyword successfully deleted",
+                "mot-cle-renomme" : "Keyword successfully renamed",
+                "liaison-mots-cles-effectuee" : "Keyword linked successfully",
+                "suppression-liaison-mot-cle-effectuee" : "Keyword unlinked successfully",
+                "requete-mal-formee" : "Bad request",
+                "impossible-geolocaliser-obs" : "Cannot locate this observation",
+                "upload-simple-fichiers" : "Simple file upload",
+                "upload-multiple-fichiers" : "Multiple files upload",
+                "indication-fin-upload-multiple-fermer" : "When the upload is complete, please close the window to access the newly uploaded images",
+                "saisie" : "Input",
+                "question-supprimer-observation" : "Are you sure you want to delete this observation",
+                "details" : "Details",
+                "inconnue" : "Unknown",
+                "erreur-nb-obs-étiquettes" : "The labels cannot be generated for more than 300 observations at a time",
+                "question-supprimer-lien-image-obs" : "Delete link between image {0} and observation {1}",
+                "question-supprimer-observation" : "Are you sure you want to delete the selected observations",
+                "question-supprimer-observations-sel" : "Are you sure you want to delete the selected observations",
+                "supprimer-selectionnees" : "Delete the selected observations",
+                "aucune-observation-selectionnee" : "No observation selected",
+                "rendre-publiques" : "make public",
+                "rendre-publiques-selectionnees" : "Make the selected observations public",
+                "rendre-privees" : "make private",
+                "rendre-privees-selectionnees" : "Make the selected observations private",
+                "question-rendre-publique-privee-observations-sel" : "Are you sure you want to {0} the selected observations",
+                "question-publication-observations-identifie" : "You need to be logged in to make your observations public, would you like to log in now ? (all your observations will be kept)",
+                "question-suppression-liaison-obs-mot-cle" : "Are you sure you want to delete the link between the observation and the keyword",
+                "explication-panneau-carto" : "Specify the location of your observation then click OK. Coordinates are given in decimal degrees, counted positively towards the North for latitude, and towards the East for longitude",
+                "recherche-coordonnees-localite" : "Searching for coordinates and location, please wait",
+                "deplacez-marqueur-pour-localiser" : "Move this marker to locate your observation (location and coordinates)",
+                "aucune-information" : "No information for this name",
+                "aucun-lieu-trouve" : "No location name found for this place",
+                "recherche-nom-lieu" : "Searching for location name...",
+                "prendre-un-moment" : "This may take a while",
+                "que-les-coordonnees" : "If you want coordinates only, you can click OK now",
+                "filtres" : "Filters",
+                "recherche" : "Search",
+                "annee" : "Year",
+                "mois" : "Month",
+                "jour" : "Day",
+                "pays" : "Country",
+                "departement" : "Department",
+                "mois-1" : "january",
+                "mois-2" : "february",
+                "mois-3" : "march",
+                "mois-4" : "april",
+                "mois-5" : "may",
+                "mois-6" : "june",
+                "mois-7" : "july",
+                "mois-8" : "august",
+                "mois-9" : "september",
+                "mois-10" : "october",
+                "mois-11": "november",
+                "mois-12" : "december",
+                "mois-inconnu" : "Unknown",
+                "indication-saisie-groupe-champ-etendus" : "You can add multiple fields at once, corresponding to a group "+
+                                                                                                        "for exemple fields from the projets 'sauvages de ma rue' or 'florilèges', etc... <br />"+
+                                                                                                        "New groups will be added on a regular basis, based on the most used fields",
+                "ajouter-groupe-champ-etendus" : "Add fields group",
+                "indication-saisie-nom-champ-etendu" : "Enter a field name or choose one from autocompletion "+
+                                                                                                "If you choose an existing field name, this field will be autocompleted "+
+                                                                                                "with values already entered by other users.<br /> "+
+                                                                                                "Fields of the form 'label (key)' are 'standards' fields having specific roles and descriptions",
+                "nom-champ-etendu" : "Field name",
+                "ajouter-fermer" : "Add and close",
+                "indication-ajouter-fermer" : "Add an extended field or a group and close the window",
+                "ajouter" : "Add",
+                "fermer" : "Close",
+                "indication-ajouter-champ-etendu" : "Add an extended field or a group",
+                "indication-fermer-champ-etendu" : "Close the window",
+                "erreur-nom-vide-champ-etendu" : "Extended field name cannot be empty",
+                "indication-aucune-description-champ-etendu" : "No description found for this field",
+                "indication-aucune-description-champ-etendu-remplir" : "You can fill it on this page",
+                "description" : "Description",
+                "creer" : "Create",
+                "modifier" : "Update",
+                "reinitialiser" : "Reset",
+                "valeurs-multiples" : "Multiple values",
+                "localite" : "Locality",
+                "station" : "Station",
+                "lat" : "Lat",
+                "latitude" : "Latitude",
+                "lon" : "Lon",
+                "longitude" : "Longitude",
+                "alt" : "Alt. (meters)",
+                "altitude" : "Altitude",
+                "coordonnees" : "Coordinates",
+                "referentiel" : "Referential",
+                "espece" : "Species",
+                "abondance" : "Abundancy",
+                "lieu-dit" : "Place",
+                "milieu" : "Environment",
+                "notes" : "Notes",
+                "identification" : "Identification",
+                "phenologie" : "Phenology",
+                "afficher-champs-etendus" : "Show extended fields",
+                "cacher-champs-etendus" : "Hide extended fields",
+                "ajouter-champ-etendu" : "Add an extended field",
+                "indication-champ-etendu-existe-deja" : "The extended field {0} already exists in the form",
+                "indication-bouton-creer-obs" : "Submit a new observation with the input values",
+                "indication-bouton-modifier-obs" : "Update selected observations",
+                "indication-bouton-reinitialiser-obs" : "Empty form",
+                "indication-bouton-supprimer-obs" : "Delete selected observations",
+                "erreur-localisation" : "localization error",
+                "localiser-zone" : "Locate the area",
+                "aide-lien-localiser" : "With a map, get the coordinates (latitude/longitude) of your observation, You can enter a name as 'locality (french department)' or 'locality (country)' "+
+                                                                "with a two-figures french departement number or a two-letters country code (iso 3166 1 format)",
+                "indication-formulaire-lat-lon" : "Lat / Lon are latitudes / longitudes, using decimal degrees",
+                "saisie-lat-lon" : "Lat/Lon input",
+                "indication-formulaire-localiser" : "Click to get the coordinates of your observation through the map",
+                "localiser-la-carte" : "Locate on the map",
+                "indication-format-date" : "Observation date jj/mm/aaaa format",
+                "indication-localite-vide-invalide" : "Please enter a locality followed by a french department number or a two-letter country code \n 'locality (department)' or 'locality (country)'",
+                "indication-date-invalide" : "Invalid date format : date must be formatted as jj/mm/aaaa",
+                "date-invalide" : "Invalid date",
+                "question-modifier-observation" : "Are you sure you want to update the selected observation",
+                "question-modifier-champs-observation" : "Do you want to update the following fields : {0} for the selected observations",
+                "indication-aucun-champ-modifie" : "No field modified",
+                "indication-premiere-presence" : "Warning, the taxon {0} has never been reported in the chorology of the french department {1},\n "+
+                 "if you are certain of your observation, you can report your discovery to the chorology forum at this adress : {2}",
+                "certain" : "Certain",
+                "douteux" : "Dubious",
+                "a-determiner" : "To be identified",
+                "abondance-5" : "5 : covering C > 75%",
+                "abondance-4" : "4 : 50% < C < 75%",
+                "abondance-3" : "3 : 25% < C < 50%",
+                "abondance-2" : "2 : 5% < C < 25%",
+                "abondance-1" : "1 : 1% < C < 5%",
+                "abondance-+" : "+ : covering C < 1%",
+                "abondance-r" : "r : rare (a few plants)",
+                "abondance-i" : "i : a single individual",
+                "abondance-1-5" : "1-5 individuals",
+                "abondance-5-10" : "5-10 individuals",
+                "abondance-10-50" : "10-50 individuals",
+                "abondance-50-100" : "50-100 individuals",
+                "abondance-100-500" : "100-500 individuals",
+                "abondance->500" : ">500 individuals",
+                "abondance-E" : "E : exceptionnal",
+                "abondance-RR" : "RR : very rare",
+                "abondance-R" : "R : rare",
+                "abondance-AR" : "AR : pretty rare",
+                "abondance-PC" : "PC : uncommon",
+                "abondance-AC" : "AC : pretty common",
+                "abondance-C" : "C : common",
+                "abondance-CC" : "CC : very common",
+                "phenologie-00-09" : "00-09: seed germination, spouting, bud development",
+                "phenologie-10-19" : "10-19: leaf development",
+                "phenologie-11" : "11: 10% of unfolded leaves",
+                "phenologie-15" : "15: 50% of unfolded leaves",
+                "phenologie-20-29" : "20-29: formation of side shoots, tillering",
+                "phenologie-30-39" : "30-39: stem and shoot elongation, rosette growth",
+                "phenologie-40-49" : "40-49: development of vegetatively propagated organs",
+                "phenologie-50-59" : "50-59: inflorescence mergence, heading",
+                "phenologie-60-69" : "60-69: flowering",
+                "phenologie-61" : "61 : 10% of flowers open",
+                "phenologie-65" : "65 : 50% of flowers open",
+                "phenologie-70-79" : "70-79: development of fruit",
+                "phenologie-80-89" : "80-89: ripening or maturity of fruit and seed",
+                "phenologie-85" : "85: 50% of fruits ripe",
+                "phenologie-90-99" : "90-99: senescence and beginning of dormancy",
+                "phenologie-91" : "91:  10% of leaves have changed color",
+                "phenologie-95" : "95: 50% of leaves have changed color",
+                "referentiel-bdtfx" : "Metropolitan France (BDTFX)",
+                "referentiel-bdtfxr" : "Metropolitan France (reduced index)",
+                "referentiel-bdtxa" : "French Antilles (BDTXA)",
+                "referentiel-bdtre" : "Reunion Island (BDTRE)",
+                "referentiel-aublet" : "French Guyana (AUBLET2)",
+                "referentiel-florical" : "New Caledonia (FLORICAL)",
+                "referentiel-apd" : "Africa (APD)",
+                "referentiel-apdfna" : "North Africa (APD)",
+                "referentiel-apdfta" : "West and Center Africa (APD)",
+                "referentiel-apdfsa" : "South Africa (APD)",
+                "referentiel-lbf" : "Lebanon (LBF)",
+                "referentiel-autre" : "Other/Unknown",
+                "licence" : "The \"online notebook\" (CEL) is a service offered by Tela Botanica in order to help you keep track of your field observations so that they no longer remain a prisoner of your \"little spiral notebook\" ... data entry is fast, safe and accurate and the CEL allows you to archive and sort them easily. If you publish them, we urge you to do, but it’s not compulsory, they will be visible on species distribution maps of Tela Botanica’s website. Similarly, you can share your best pictures of plants with other members of the network. You can also export your comments entered in the CEL in an Excel table to handle statistically, transfer them to other botanists or other software.<br />"
+                        +"<br />"
+                        +"For that, you must accept the following conditions :<br />"
+                        +"<br />"
+                        +"1. <b>Being registered in Tela Botanica’s network</b> : this registration is free and you will find all explanations at : <a href=\"http://www.tela-botanica.org/page:rejoindre_reseau\">http://www.tela-botanica.org/page:rejoindre_reseau</a><br />"
+                        +"<br />"
+                        +"2. <b>By publishing your observations on Tela Botanica’s website you agree to assign</b> :<br />"
+                        +"- <u>an internal right of use by Tela Botanica</u>, non-exclusive, unlimited in time and free of charge, on all published data, notably the right to hold, duplicate, archive, aggregate with data from other sources and perform any type of calculation to extract general information, such as statistics, for example. <br />"
+                        +"- <u>The right to Tela Botanica to disseminate data freely and free of charge</u>, with no time limit, provided that the name of the author of the observation and the name of Tela Botanica are cited. However, in the event that a publication would include more than 100 different authors, only the term \"Tela Botanica network\" will be mentioned<br />"
+                        +"<br />"
+                        +"3. <b>You may withdraw the published data you want at any time</b>. In this case the provisions of the previous Article no longer apply to data and removed from the publication, without any time to return to the previously assigned rights upon initial publication in cases where the data has already been used by third parties.<br />"
+                        +"<br />"
+                        +"4. <b>By publishing your photos on TB’s website</b>, you agree to make them available to the community under a license <a href = \"http://www.tela-botanica.org/page:license\"> Creative Commons </a>. This provision is applicable only to the reduced size of your images presented on the Tela Botanica’s website. It does not apply to images in their original format in high definition that you keep the property. Under this license <a href=\"http://www.tela-botanica.org/page:licence\"> Creative Commons </a> any person shall be free to reproduce, modify, distribute and transmit the picture to the public under the following conditions :<br />"
+                        +"- mention the name of the original author of the work and that of Tela Botanica who edits,<br />"
+                        +"- if there is change, transformation, or adaptation works, you must give the right to distribute the resulting work only under a license identical to this one,<br />"
+                        +"- at any reuse or distribution, contractual terms of provision of this creation must be clear mentioned,<br />"
+                         +"- each of these conditions can be waived with the permission of the copyright holder.<br />"
+                         +"<br />"
+                         +"<br />"
+                        +"5. <b>By publishing your data (photos and / or observations) on Tela Botanica’s website</b> you agree that network members can contact you via your email address to discuss with you the relevance of your determination, his place of observation or the title of your photos.<br />"
+                        +"<br />"
+                        +"Posting your identity will appear as the full name you have filled in during registration at Tela Botanica’s network. Only the last part of the @ sign in your email address will be displayed to prevent its use by third parties. The messages which arrive will be send by Tela Botanica via a device ensuring non hacking your address.<br />"
+}

 /trunk/war/config.defaut.js
 New file
 ,0 → 1,31
+// à renommer en config.js
+var configuration = {
+        prod: false, // si true, enverra notamment des stats à Google Analytics
+        identificationBaseUrl:"https://localhost/annuaire/jrest/Auth",
+        serviceBaseUrl:"http://localhost/jrest",
+        suiviBugUrl:"http://www.tela-botanica.net/suivi/index.php?do=newtask&project=2",
+        aideBaseUrl:"http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=AideCEL",
+        remarquesBaseUrl:"http://www.tela-botanica.org/widget:reseau:remarques",
+        serviceContact:"cel",
+        imageBaseUrl:"http://localhost/Documents/images_serveur/",
+        imageRedirectUrl:"http://localhost/appli:cel-img:",
+        utiliseRedirectionImage:"1",
+        referentielGeo:"WGS84",
+        cleGoogleMaps:"ABQIAAAADBUAHF9l14gI02QVAbUYJBRqPsByHDhzHLE0yoC9hASLZaFmoRT4_9Zkiscf-BaH_gEy7DVHX5BxwQ",
+        referentielsDispos:"bdtfxr:v3.02;bdtfx:v3.02;bdtxa:v1.01;bdtre:v0.01;florical:v1.00;aublet:v1.00;apd:v2017;lbf:v1.00;autre",
+        lienEfloreBaseUrl:"www.tela-botanica.org/eflore",
+        licence:"",
+        tailleMaxUpload:"10000000",
+        formatOriginal: "O",
+        formatZoom: "X3L",
+        formatGalerie: "XS",
+        formatListe: "XS",
+        activerSaisieChampsEtendus: "0",
+        wikiDescriptionChampsEtendusPageUrl: "http://localhost/yeswiki/wakka.php?wiki=",
+        wikiDescriptionChampsEtendusRestUrl: "http://localhost/yeswiki/api/rest/0.5/pages/",
+        wikiDescriptionChampsEtendusRestUrlOptions : "txt.format=text/plain&txt.section.titre=description courte",
+        wikiDescriptionChampsEtendusUrlOptionsPageTpl : "&txt.template=tplChampEtendu",
+        langueDefaut: "fr",
+        languesDisponibles: "fr,en",
+        chorologieAvertissementCourriel: "http://www.tela-botanica.org/projets-9"
+};

 /trunk/war/cel2.html
 New file
 ,0 → 1,79
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!-- The HTML 4.01 Transitional DOCTYPE declaration-->
+<!-- above set at the top of the file will set     -->
+<!-- the browser's rendering engine into           -->
+<!-- "Standards Mode", which gives better cross    -->
+<!-- browser compatibility to the application.     -->
+<!-- Omitting this line leaves most browsers in    -->
+<!-- "Quirks mode", emulating the bugs in older    -->
+<!-- browser versions.                             -->
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <!--                                           -->
+    <!-- Any title is fine                         -->
+    <!--                                           -->
+    <title>CEL - v2.27 Sécateur</title>
+        <!-- OpenGraph pour Facebook, Pinterest, Google+ -->
+        <meta property="og:type" content="website" />
+        <meta property="og:title" content="Carnet en Ligne" />
+        <meta property="og:site_name" content="Tela Botanica" />
+        <meta property="og:description" content="Saisissez, gérez et partagez vos observations botaniques grâce au Carnet en Ligne, l'équivalent numérique de votre carnet de terrain" />
+        <meta property="og:image" content="http://resources.tela-botanica.org/tb/img/256x256/carre_englobant.png" />
+        <meta property="og:image:type" content="image/png" />
+        <meta property="og:image:width" content="256" />
+        <meta property="og:image:height" content="256" />
+        <meta property="og:locale" content="fr_FR" />
+    <!--                                           -->
+    <!-- This script loads your compiled module.   -->
+    <!-- If you add any GWT meta tags, they must   -->
+    <!-- be added before this line.                -->
+        <link rel="stylesheet" href="org.tela_botanica.cel2/js/ext/resources/css/ext-all.css" />
+        <script type="text/javascript" language="javascript" src="i18n/messages_fr.js"></script>
+        <script type="text/javascript" language="javascript" src="i18n/messages_en.js"></script>
+        <script type="text/javascript" language="javascript" src="i18n/messages_nl.js"></script>
+        <script type="text/javascript" language="javascript" src="config.js"></script>
+        <script type="text/javascript" language="javascript" src="org.tela_botanica.cel2/js/ext/adapter/ext/ext-base.js" /></script>
+        <script type="text/javascript" language="javascript" src="org.tela_botanica.cel2/js/ext/ext-all.js" /></script>
+        <script type="text/javascript" language="javascript" src="org.tela_botanica.cel2/js/UploadDialog/Ext.ux.UploadDialog.packed.js" /></script>
+        <script type="text/javascript" language="javascript" src="i18n/traductionMetadonnees_en.js"></script>
+        <script type="text/javascript" language="javascript" src="i18n/traductionMetadonnees_fr.js"></script>
+        <script type="text/javascript" language="javascript" src="org.tela_botanica.cel2/org.tela_botanica.cel2.nocache.js"></script>
+        <link rel="stylesheet" href="cel2.css">
+        <link rel="stylesheet" href="GwtExt.css">
+        <script>
+          (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+          })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+          ga('create', 'UA-57885-6', 'auto');
+        </script>
+  </head>
+  <!--                                           -->
+  <!-- The body can have arbitrary html, or      -->
+  <!-- you can leave the body empty if you want  -->
+  <!-- to create a completely dynamic UI.        -->
+  <!--                                           -->
+  <body>
+    <!-- OPTIONAL: include this if you want history support -->
+    <iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe>
+        <!--add loading indicator while the app is being loaded-->
+                <div id="loading" class="splash_screen">
+                        <span id="texte_chargement"> </span>
+                        <img id="icone_chargement" src="chargement_splash.gif" />
+                <img src="splash_screen.png" />
+                </div>
+  </body>
+</html>

/trunk/war/note-hover.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/war/chargement_splash.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/war/Fleche_droite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/war/history.html
 New file
 ,0 → 1,21
+<html>
+<head>
+<script>
+function hst() {
+  var search = location.search;
+  var historyToken = '';
+  if (search.length > 0)
+    historyToken = search.substring(1);
+  document.getElementById('__gwt_historyToken').value = historyToken;
+  if (parent.__gwt_onHistoryLoad) {
+    parent.__gwt_onHistoryLoad(historyToken);
+  }
+}
+</script></head>
+<body onload='hst()'>
+<input type='text' id='__gwt_historyToken' tabIndex='-1'>
+</body>
+</html>

/trunk/war/Fleche_gauche.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/war/index.html
 New file
 ,0 → 1,8
+<html>
+  <head>
+    <title></title>
+    <meta http-equiv="refresh" content="0; url=cel2.html" />
+    <style></style>
+  </head>
+  <body></body>
+</html>

 /trunk/war/.htaccess
 New file
 ,0 → 1,13
+#AddHandler x-httpd-php5 .php
+AddDefaultCharset UTF-8
+<Files *.nocache.*>
+  ExpiresActive on
+  ExpiresDefault "now"
+  Header merge Cache-Control "public, max-age=0, must-revalidate"
+</Files>
+<Files *.cache.*>
+  ExpiresActive on
+  ExpiresDefault "now plus 1 year"
+</Files>

/trunk/war/wjhk.jupload.jar
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/war/statistiques.php
 New file
 ,0 → 1,49
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
+        <head>
+                <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+                <title>Statistiques du Carnet En Ligne</title>
+                <style>
+                        img{display:block;margin:0.5em;border:1px solid black;}
+                        hr.nettoyeur {clear:both;width:0;}
+                        .flottant-gauche img{float:left;}
+                </style>
+        </head>
+        <body>
+                <?php $i=0;?>
+                <h1>Statistiques du CEL</h1>
+                <div class="flottant-gauche">
+                        <h2>Activitée</h2>
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/UtilisationJournaliere/<?=$i++?>/<?=date("Y-m-d", (time() - 86400))?>" alt="Intensité d'utilisation pour la journée d'hier" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/UtilisationJournaliere/<?=$i++?>" alt="Intensité d'utilisation pour aujourd'hui" />
+                </div>
+                <hr class="nettoyeur" />
+                <div class="flottant-gauche">
+                        <h2>Données</h2>
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsIdVsTest/<?=$i++?>" alt="Nombre d'observations identifiées versus tests" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsPublicVsPrivee/<?=$i++?>" alt="Nombre d'observations publiques versus privées" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsDetermineeVsInconnue/<?=$i++?>" alt="Nombre d'observations déterminées versus inconnues" />
+                        <hr class="nettoyeur" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsAvecIndicationGeo/<?=$i++?>" alt="Nombre d'observations avec indications géographiques" />
+                </div>
+                <hr class="nettoyeur" />
+                <div class="flottant-gauche">
+                        <h2>Utilisateurs</h2>
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NuagePointsObsParHeureEtJourSemaine/<?=$i++?>" alt="Nuage de points d'observation par heure et jour de la semaine" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NuagePointsObsAnciennete/<?=$i++?>" alt="Répartition des utilisateurs en fonction du nombre d'observations et de l'ancienneté" />
+                        <hr class="nettoyeur" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsParUtilisateur/<?=$i++?>" alt="Nombre d'observations par utilisateur" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/NbreObsParUtilisateurEtTest/<?=$i++?>" alt="Nombre d'observations par utilisateur et test" />
+                        <hr class="nettoyeur" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/EvolUtilisateurParMois/<?=$i++?>" alt="Nombre d'observations par utilisateur et test" />
+                </div>
+                <hr class="nettoyeur" />
+                <div>
+                        <h2>Évolution</h2>
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/EvolObsParMoisGlissant/<?=$i++?>" alt="Évolutions des observation sur le dernier mois glissant" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/EvolObsParMois/<?=$i++?>" alt="Évolutions des observation par mois" />
+                        <img src="http://www.tela-botanica.org/eflore/cel2/jrest/CelStatistique/EvolObsParAn/<?=$i++?>" alt="Évolutions des observation par an" />
+                </div>
+                <hr class="nettoyeur" />
+         </body>
+</html>

 /trunk/war/hosted.html
 New file
 ,0 → 1,40
+<html>
+<head><script>
+var $wnd = parent;
+var $doc = $wnd.document;
+var $moduleName, $moduleBase
+,$stats = $wnd.__gwtStatsEvent ? function(a) {return $wnd.__gwtStatsEvent(a);} : null;
+if ($stats) {
+  var moduleFuncName = location.search.substr(1);
+  var moduleFunc = $wnd[moduleFuncName];
+  var moduleName = moduleFunc ? moduleFunc.moduleName : "unknown";
+  $stats({moduleName:moduleName,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalStart'});
+}
+</script></head>
+<body>
+<font face='arial' size='-1'>This html file is for hosted mode support.</font>
+<script><!--
+function gwtOnLoad(errFn, modName, modBase){
+  $moduleName = modName;
+  $moduleBase = modBase;
+  if (!external.gwtOnLoad(window, modName, "1.5")) {
+    if (errFn) {
+      errFn(modName);
+    }
+  }
+}
+window.fireOnModuleLoadStart = function(className) {
+  $stats && $stats({moduleName:$moduleName, subSystem:'startup', evtGroup:'moduleStartup', millis:(new Date()).getTime(), type:'onModuleLoadStart', className:className});
+};
+window.onunload = function() {
+  external.gwtOnLoad(window, null, "1.5");
+};
+window.__gwt_module_id = 0;
+var query = window.location.search.substr(1);
+$stats && $stats({moduleName:$moduleName,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalEnd'});
+if (query && $wnd[query]) $wnd[query].onScriptLoad();
+--></script></body></html>

/trunk/war/clear.cache.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/war/chargement_carte.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/build.properties
 New file
 ,0 → 1,27
+# build.properties est écrasé par local.properties, s'il existe
+# Mettre seulement les propriétés communes à toutes les installations
+projectName = org.tela_botanica.cel2
+# pour la compilation "rapide" (ant quick)
+projectTestName = org.tela_botanica.cel-test
+# machine sur laquelle lancer le CeL en mode hosted
+cel-host = localhost
+cel-base-url = war/cel2.html
+# note: les répertoires de gwt, gwt-google-api, gwtext et gwtextux sont fixé relatif à ${gwt-path} dans build.xml
+gwt-path = ${user.home}/gwt
+gwt-maps-path = lib/gwt-maps-3.8.0
+gwt-ext-path = lib/gwtext-2.0.5
+gwt-ext-ux-path = lib/gwtextux-0.3
+# doit contenir ext-all.js, resources et adapter/ext/ext-base.js
+# Ces ressources sont nécessaire pour les widgets de gwt-ext-ux
+# et ce dernier attend des images dans resources/images du répertoire
+# de extjs.
+# Or, en extjs 4.2.1 par exemple, les ressources se trouvent désormais
+# dans resources/themes/images. Ainsi 2.0.2 est supportée, mais 4.2.1 ne l'est pas.
+ext-js-dir = vendors/extjs-2.0.1
+# Destination des fichiers .js / .css de extjs , dans le war (pas de raison de le changer)
+js-dest-dir = war/${projectName}/js
+ext-js-dest-dir = ${js-dest-dir}/ext

 /trunk/build.xml
 New file
 ,0 → 1,94
+<project name="cel" xmlns:artifact="urn:maven-artifact-ant" basedir=".">
+  <property file="local.properties" />
+  <property file="build.properties"/>
+  <target name="generate-vocabulary">
+        <java classname="com.google.gwt.i18n.tools.I18NSync" fork="true">
+          <arg value="org.tela_botanica.client.i18n.VocabulaireMetadonnees" />
+          <classpath>
+                <path>
+                  <pathelement location="${gwt-path}/gwt-user.jar" />
+                  <pathelement location="${gwt-path}/gwt-dev.jar" />
+                  <pathelement location="src" />
+                </path>
+          </classpath>
+        </java>
+  </target>
+  <target name="generate-messages">
+        <java classname="com.google.gwt.i18n.tools.I18NSync" fork="true">
+          <arg value="org.tela_botanica.client.i18n.Messages" />
+          <classpath>
+                <path>
+                  <pathelement location="${gwt-path}/gwt-user.jar" />
+                  <pathelement location="${gwt-path}/gwt-dev.jar" />
+                  <pathelement location="src" />
+                </path>
+          </classpath>
+        </java>
+  </target>
+  <path id="gwt">
+        <fileset includes="*.jar" dir="${gwt-path}" />
+        <fileset includes="*.jar" dir="${gwt-maps-path}" />
+        <fileset includes="gwtext.jar" dir="${gwt-ext-path}" />
+        <fileset includes="*.jar" dir="${gwt-ext-ux-path}" />
+        <pathelement location="src" />
+  </path>
+  <target name="link-resources">
+        <mkdir dir="${ext-js-dest-dir}"/>
+        <mkdir dir="${ext-js-dest-dir}/resources"/>
+        <mkdir dir="${ext-js-dest-dir}/adapter/ext"/>
+        <copy file="${ext-js-dir}/ext-all.js" todir="${ext-js-dest-dir}"/>
+        <copy todir="${ext-js-dest-dir}/resources">
+          <fileset dir="${ext-js-dir}/resources"/>
+        </copy>
+        <copy file="${ext-js-dir}/adapter/ext/ext-base.js" todir="${ext-js-dest-dir}/adapter/ext"/>
+        <copy todir="${js-dest-dir}/UploadDialog" overwrite="true">
+          <fileset dir="vendors/gwt-ext-ux/UploadDialog"/>
+        </copy>
+  </target>
+  <!-- Affiche toutes les propriétés -->
+  <target name="test"><echoproperties/></target> <!-- sometimes useful -->
+  <!-- Compile l'application pour la prod -->
+  <target name="compile">
+        <java classname="com.google.gwt.dev.Compiler" fork="true">
+          <arg line="-localWorkers 2 -style DETAILED ${projectName}"/>
+          <classpath refid="gwt"/>
+        </java>
+        <antcall target="link-resources"></antcall>
+  </target>
+  <!-- Compilation rapide (draft) -->
+  <target name="compile-quick">
+        <java classname="com.google.gwt.dev.Compiler" fork="true">
+          <arg line="-style DETAILED -draftCompile ${projectTestName}" />
+          <classpath refid="gwt"/>
+        </java>
+        <antcall target="link-resources"></antcall>
+  </target>
+  <!-- Compilation debug (avec plein de logs) -->
+  <target name="compile-debug">
+        <java classname="com.google.gwt.dev.Compiler" fork="true">
+          <arg line="-style DETAILED -logLevel DEBUG"/>
+          <arg value="${projectName}" />
+          <classpath refid="gwt"/>
+        </java>
+        <antcall target="link-resources"></antcall>
+  </target>
+  <!-- Lance l'application en mode hosted -->
+  <target name="launch-hosted">
+        <java classname="com.google.gwt.dev.DevMode" spawn="true" fork="true">
+          <arg line="-startupUrl http://${cel-host}/${cel-base-url} -noserver -codeServerPort auto ${projectName}" />
+          <classpath refid="gwt"/>
+        </java>
+  </target>
+</project>

 /trunk/lib/gwtextux-0.3/about.txt
 New file
 ,0 → 1,9
+GWT-Ext UX @GWTEXTUX_VERSION@
+Visit Project Page (http://code.google.com/p/gwt-ext-ux/).
+This product includes software developed by:
+ - The Google Web Toolkit(GWT) project (http://code.google.com/webtoolkit/)
+ - The Ext project (http://www.extjs.com/)
+ - The GWT-Ext project (http://www.gwt-ext.com/)
+For source availability and license information see COPYING.html

/trunk/lib/gwtextux-0.3/gwtextux.jar
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/lib/gwtextux-0.3/index.html
 New file
 ,0 → 1,94
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+      <meta http-equiv="content-type" content="text/html; charset=utf-8">
+      <title>GWT-Ext UX @GWTEXTUX_VERSION@</title>
+      <style>
+         body {
+            background-color: white;
+            color: black;
+            font-family: Arial, sans-serif;
+            font-size: small;
+            margin: 20px;
+         }
+         li {
+            margin-bottom: 0.5em;
+         }
+         li div {
+            margin-top: 0.2em;
+         }
+         code {
+            font-size: medium;
+         }
+      </style></head>
+   <body>
+      <h1>GWT-Ext UX @GWTEXTUX_VERSION@</h1>
+      The GWT-Ext UX Widget Extensions
+      <h2>Resources</h2>
+      <ul>
+         <li>
+            <a href="release_notes.html" target="_blank">Release Notes</a>
+            <div>
+               Details about this release and previous releases.
+            </div>
+         </li>
+          <li>
+            <a href="http://www.gwt-ext.com/">GWT-Ext Home</a> (online)
+            <div>
+               GWT-Ext Home Page.
+            </div>
+         </li>
+          <li>
+            <a href="http://code.google.com/p/gwt-ext-ux/">GWT-Ext User Extensions (UX) Home</a> (online)
+            <div>
+               GWT-Ext User Extensions (UX) Home.
+            </div>
+         </li>
+          <li>
+            <a href="http://www.gwt-ext.com/forum">Developer Forum</a> (online)
+            <div>
+               The Developer Forum is the best place to go to discuss GWT-Ext, ask or
+               answer questions, report bugs, and sync up with other developers.
+            </div>
+         </li>
+         <li>
+            <a href="http://www.gwt-ext.com/wiki">Wiki</a> (online)
+            <div>
+               Updates on the project will be posted here.
+            </div>
+         </li>
+         <li>
+            <a href="http://code.google.com/webtoolkit/">Google Web Toolkit Home</a> (online)
+            <div>
+               Google Web Toolkit Home Page.
+            </div>
+         </li>
+         <li>
+            <a href="http://extjs.com/">Ext Home</a> (online)
+            <div>
+               Ext Home page.
+            </div>
+         </li>
+      </ul>
+      <h2>Starting Points</h2>
+      <ul>
+         <li>
+            <a href="http://www.gwt-ext.com/wiki">Getting Started Guide</a> (online)
+            <div>
+               A step-by-step tutorial on creating your first app from scratch.
+            </div>
+         </li>
+         <li>
+            <a href="doc/javadoc/index.html">Javadocs</a>
+            <div>
+               The API documentation in standard Javadoc form.
+            </div>
+         </li>
+      </ul>
+   </body></html>

 /trunk/lib/gwtextux-0.3/COPYING.html
 New file
 ,0 → 1,126
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<title>GWT-Ext License Information</title>
+<style type="text/css">
+p.heading {
+    font-weight: bold;
+}
+.licenses {
+    border-collapse: separate;
+}
+.licenses th {
+    text-align: left;
+    background-color: #ccccff;
+    padding: 3px;
+}
+.licenses td {
+    background-color: #f4f4f4;
+    padding: 3px;
+    text-align: left;
+    vertical-align: top;
+}
+.licenses tr.even td {
+    background-color: #eeeeee;
+}
+</style></head>
+<body>
+<div id="body">
+<h1>GWT-Ext License Information</h1>
+<p>The GWT-Ext software and sample code is licensed under the BSD</p>
+<p><a href="http://en.wikipedia.org/wiki/BSD_license">http://en.wikipedia.org/wiki/BSD_license</a></p>
+<a name="licenses"></a>
+<h2>LICENSE INFORMATION REGARDING RELATED THIRD-PARTY SOFTWARE</h2>
+<p>The GWT-Ext library relies on the following third party software. Below is the location and license information :
+</p>
+<table class="licenses">
+  <tbody><tr>
+    <th>Package</th>
+    <th>License</th>
+    <th>Details</th>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://code.google.com/webtoolkit/">Google Web Toolkit</a></td>
+    <td class="license"><a href="http://code.google.com/webtoolkit/terms.html">Apache License v. 2.0</a></td>
+    <td class="location"><a href="http://code.google.com/webtoolkit/">http://code.google.com/webtoolkit/</a></td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://www.extjs.com/">Ext 2.0.2</a></td>
+    <td class="license">Ext 2.0.2 has several licensing options available to fit a variety of needs. LGPL 3.0 is one of them.</td>
+    <td class="location"><a href="http://yogurtearl.com/ext-2.0.2.zip">http://yogurtearl.com/ext-2.0.2.zip</a> or the extjs.com site</td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://www.gwt-ext.com/">GWT-Ext</a></td>
+    <td class="license"><a href="http://www.gnu.org/licenses/lgpl.html">LGPL 3.0</a>. See <a href="http://gwt-ext.com/license">http://gwt-ext.com/license</a> for details</td>
+    <td class="location"><a href="http://gwt-ext.com/download">http://www.gwt-ext.com/download</a></td>
+  </tr>
+  <tr>
+    <td class="package">PagingMemoryProxy</td>
+    <td class="license"><a href="http://www.gnu.org/licenses/lgpl.html">LGPL</a></td>
+    <td class="location"><a href="http://extjs.com/learn/Extention:PagingMemoryProxy">http://extjs.com/learn/Extention:PagingMemoryProxy</a></td>
+  </tr>
+  <tr>
+    <td class="package">RowLayout</td>
+    <td class="license"><a href="http://www.gnu.org/licenses/lgpl.html">LGPL</a></td>
+    <td class="location"><a href="http://extjs.com/forum/showthread.php?t=17116">Kirill Hryapin</a></td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://extjs.com/learn/Extension:Multiselect2">MultiSelect</a></td>
+    <td class="license"><a href="http://extjs.com/learn/Extension:Multiselect2">LGPL 3.0 / Ext License</a></td>
+    <td class="location"><a href="http://extjs.com/learn/Extension:Multiselect2">http://extjs.com/learn/Extension:Multiselect2</a></td>
+  </tr>
+  <tr>
+    <td class="package">Grid Filter Plugin</td>
+    <td class="license">LGPL</td>
+    <td class="location"><a href="http://gridsearch.extjs.eu">http://gridsearch.extjs.eu</a></td>
+  </tr>
+  <tr>
+    <td class="package">ManagedIFrame</td>
+    <td class="license">LGPL</td>
+    <td class="location"><a href="http://extjs.com/learn/Extension:ManagedIframe">http://extjs.com/learn/Extension:ManagedIframe</a></td>
+  </tr>
+  <tr>
+    <td class="package">Live Grid</td>
+    <td class="license">LGPL</td>
+    <td class="location"><a href="http://www.siteartwork.de/livegrid">http://www.siteartwork.de/livegrid</a></td>
+  </tr>
+   <tr>
+    <td class="package">MultiMonth</td>
+    <td class="license">LGPL</td>
+    <td class="location"><a href="http://extjs.com/learn/Extension:Multi_Month_Calendar">http://extjs.com/learn/Extension:Multi_Month_Calendar</a></td>
+  </tr>
+    <tr>
+    <td class="package">Upload Dialog</td>
+    <td class="license">Freeware</td>
+    <td class="location"><a href="http://max-bazhenov.com/dev/upload-dialog-2.0/index.php">http://max-bazhenov.com/dev/upload-dialog-2.0/index.php</a></td>
+  </tr>
+<tr>
+    <td class="package">SwfUploaf</td>
+    <td class="license">MIT</td>
+    <td class="location"><a href="http://www.silverbiology.com/ext_samples/SwfUploadPanel/uploaddemo.php">http://www.silverbiology.com/ext_samples/SwfUploadPanel/uploaddemo.php</a></td>
+  </tr>
+  </tbody></table>
+</div>
+</body></html>

 /trunk/lib/gwtextux-0.3/release_notes.html
 New file
 ,0 → 1,135
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <title>GWT-Ext UX 0.1 Release Notes</title>
+    <style>
+        body {
+            background-color: white;
+            color: #333333;
+            font-family: arial, helvetica, sans-serif;
+            font-size: 12px;
+            margin: 20px;
+        }
+        li {
+            margin-bottom: 0.5em;
+        }
+        li div {
+            margin-top: 0.2em;
+        }
+        code {
+            font-size: medium;
+        }
+    </style>
+</head>
+<body>
+<h1>GWT-Ext UX Release Notes</h1>
+<ul>
+    <li><a href="#0_2">0.3</a></li>
+    <li><a href="#0_2">0.2</a></li>
+    <li><a href="#0_1_1">0.1.1</a></li>
+</ul>
+<hr/>
+<a name="0_3"></a>
+<h2>Release Notes for GWT-Ext UX 0.3</h2>
+<h3>Features</h3>
+<ul>
+    <li><b>GWT 1.5 RC1 Support</b>
+    </li>
+</ul>
+<ul>
+    <li><b>FileTreePanel</b>
+    </li>
+</ul>
+<ul>
+    <li><b>SwfUploadPanel</b>
+    </li>
+</ul>
+<ul>
+    <li><b>CustomReader</b>
+    </li>
+</ul>
+<ul>
+    <li><b>CellActions Grid Plugin</b>
+    </li>
+</ul>
+<ul>
+    <li><b>Removed individual UX from GwtExtUx.gwt.xml. This means whenever a UX is needed, They have to be added individually in the users gwt.xml file. </b>
+    </li>
+</ul>
+<ul>
+    <li><b>Latest patch in Multiselect.js including memory leak fixes, drag back, etc...</b>
+    </li>
+</ul>
+<hr/>
+<a name="0_2"></a>
+<h2>Release Notes for GWT-Ext UX 0.2</h2>
+<h3>Features</h3>
+<ul>
+    <li><b>Live Grid</b>
+        <br>Virtual grid with no paging toolbar but dynamic data retreival from server
+    </li>
+</ul>
+<ul>
+    <li><b>Grid Filter Plugin</b>
+    </li>
+</ul>
+<ul>
+    <li><b>Image Component</b>
+    </li>
+</ul>
+<ul>
+    <li><b>ManagedIFrame</b>
+    </li>
+</ul>
+<ul>
+    <li><b>Grid with Proxy</b>
+    </li>
+</ul>
+<ul>
+    <li><b>Multiple Month Calendar</b>
+    </li>
+</ul>
+<ul>
+    <li><b>File Upload Dialog</b>
+    </li>
+</ul>
+<hr/>
+<a name="0_1_1"></a>
+<h2>Release Notes for GWT-Ext UX 0.1.1</h2>
+<h3>Features</h3>
+<ul>
+    <li><b>PagingMemoryProxy</b>
+        <br>Supports paging of in-memory data
+    </li>
+</ul>
+<ul>
+    <li><b>MultiSelect / ItemSelect</b>
+        <br>Supports dual item form selector
+    </li>
+</ul>
+<ul>
+    <li><b>RowLayout</b>
+        <br>Flexible layout manager for row / vertical lay out of components.
+    </li>
+</ul>
+</body>
+</html>

 /trunk/lib/gwtextux-0.3/about.html
 New file
 ,0 → 1,65
+<html>
+   <head>
+      <title>GWT-Ext UX @GWTEXTUX_VERSION@</title>
+      <style>
+         body {
+            background-color: white;
+            color: black;
+            font-family: Arial, sans-serif;
+            font-size: 10pt;
+            margin: 20px;
+            overflow: hidden;
+         }
+         #title {
+            font-size: 14pt;
+            font-weight: bold;
+         }
+         #title a {
+            text-decoration: none;
+         }
+         #version {
+            font-size: 8pt;
+            font-weight: bold;
+            text-align: right;
+         }
+         #intro {
+            margin: 10px 0px 10px 0px ;
+         }
+         #attribs {
+         }
+      </style>
+   </head>
+   <body>
+      <table align="center">
+         <tr>
+            <td id="title"><a href="http://code.google.com/p/gwt-ext-ux/">GWT-Ext UX</a></td>
+         </tr>
+         <tr>
+            <td id="version">Version @GWTEXTUX_VERSION@</td>
+         </tr>
+      </table>
+      <hr/>
+      <div id="attribs">
+         This product uses software developed by
+         <ul>
+            <li>The <a href="http://code.google.com/webtoolkit">Google Web Toolkit (GWT) Project</a></li>
+            <li>The <a href="http://www.extjs.com/">Ext Project</a></li>
+            <li>The <a href="http://www.gwt-ext.com/">GWT-Ext Project</a></li>
+         </ul>
+         For source availability and license information see COPYING.html.
+      </div>
+   </body>
+</html>

 /trunk/lib/gwtext-2.0.5/COPYING
 New file
 ,0 → 1,34
+           GWT-Ext LICENSE INFORMATION
+The GWT-Ext software and sample code is licensed under the GNU Lesser General Public Licence (LGPL), v 3.0.
+http://www.gnu.org/licenses/lgpl.html
+Source code for software included in this distribution is available from the GWT-Ext
+project (http://www.gwt-ext.com/) or as otherwise indicated at the bottom of this page.
+Questions? licensing@gwt-ext.com
+LICENSE INFORMATION REGARDING RELATED THIRD-PARTY SOFTWARE
+The GWT-Ext library relies on the following third party software. Below is the location and license information :
+* Google Web Toolkit (GWT)
+  License: Apache License v. 2.0 (above)
+  http://code.google.com/webtoolkit/
+* Ext
+  License: Ext has several licensing options available to fit a variety of needs. LGPL 3.0 is one of them.
+    See http://extjs.com/license for more information
+    http://extjs.com/download
+* Yahoo! User Interface Library (YUI)
+  License : BSD
+  http://developer.yahoo.com/yui/
+* Mapstraction
+  License : BSD
+  http://mapstraction.com/

 /trunk/lib/gwtext-2.0.5/about.txt
 New file
 ,0 → 1,8
+GWT-Ext 2.0.2
+Visit Project Page (http://www.gwt-ext.com/).
+This product includes software developed by:
+ - The Google Web Toolkit(GWT) project (http://code.google.com/webtoolkit/)
+ - The Ext project (http://www.extjs.com/)
+For source availability and license information see COPYING.

 /trunk/lib/gwtext-2.0.5/index.html
 New file
 ,0 → 1,88
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+      <meta http-equiv="content-type" content="text/html; charset=utf-8">
+      <title>GWT-Ext 2.0.2</title>
+      <style>
+         body {
+            background-color: white;
+            color: black;
+            font-family: Arial, sans-serif;
+            font-size: small;
+            margin: 20px;
+         }
+         li {
+            margin-bottom: 0.5em;
+         }
+         li div {
+            margin-top: 0.2em;
+         }
+         code {
+            font-size: medium;
+         }
+      </style></head>
+   <body>
+      <h1>GWT-Ext 2.0.2</h1>
+      The GWT-Ext Widget Library
+      <h2>Resources</h2>
+      <ul>
+         <li>
+            <a href="release_notes.html" target="_blank">Release Notes</a>
+            <div>
+               Details about this release and previous releases.
+            </div>
+         </li>
+          <li>
+            <a href="http://www.gwt-ext.com/">GWT-Ext Home</a> (online)
+            <div>
+               GWT-Ext Home Page.
+            </div>
+         </li>
+          <li>
+            <a href="http://www.gwt-ext.com/forum">Developer Forum</a> (online)
+            <div>
+               The Developer Forum is the best place to go to discuss GWT-Ext, ask or
+               answer questions, report bugs, and sync up with other developers.
+            </div>
+         </li>
+         <li>
+            <a href="http://www.gwt-ext.com/wiki">Wiki</a> (online)
+            <div>
+               Updates on the project will be posted here.
+            </div>
+         </li>
+         <li>
+            <a href="http://code.google.com/webtoolkit/">Google Web Toolkit Home</a> (online)
+            <div>
+               Google Web Toolkit Home Page.
+            </div>
+         </li>
+         <li>
+            <a href="http://extjs.com/">Ext Home</a> (online)
+            <div>
+               Ext Home page.
+            </div>
+         </li>
+      </ul>
+      <h2>Starting Points</h2>
+      <ul>
+         <li>
+            <a href="http://www.gwt-ext.com/wiki">Getting Started Guide</a> (online)
+            <div>
+               A step-by-step tutorial on creating your first app from scratch.
+            </div>
+         </li>
+         <li>
+            <a href="doc/javadoc/index.html">Javadocs</a>
+            <div>
+               The API documentation in standard Javadoc form.
+            </div>
+         </li>
+      </ul>
+   </body></html>

 /trunk/lib/gwtext-2.0.5/COPYING.html
 New file
 ,0 → 1,87
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8">
+<title>GWT-Ext License Information</title>
+<style type="text/css">
+p.heading {
+    font-weight: bold;
+}
+.licenses {
+    border-collapse: separate;
+}
+.licenses th {
+    text-align: left;
+    background-color: #ccccff;
+    padding: 3px;
+}
+.licenses td {
+    background-color: #f4f4f4;
+    padding: 3px;
+    text-align: left;
+    vertical-align: top;
+}
+.licenses tr.even td {
+    background-color: #eeeeee;
+}
+</style></head>
+<body>
+<div id="body">
+<h1>GWT-Ext License Information</h1>
+<p>The GWT-Ext software and sample code is licensed under the GNU Lesser General Public Licence (LGPL), v 3.0.</p>
+<p><a href="http://www.gnu.org/licenses/lgpl.html">http://www.gnu.org/licenses/lgpl.html</a></p>
+<p>Source code for software included in this distribution is available from the GWT-Ext project (http://www.gwt-ext.com/)
+        or as otherwise indicated at the bottom of this page.</p>
+<p>Questions? <a href="mailto:licensing@gwt-ext.com">licensing@gwt-ext.com</a></p>
+<a name="licenses"></a>
+<h2>LICENSE INFORMATION REGARDING RELATED THIRD-PARTY SOFTWARE</h2>
+<p>The GWT-Ext library relies on the following third party software. Below is the location and license information :
+</p>
+<table class="licenses">
+  <tbody><tr>
+    <th>Package</th>
+    <th>License</th>
+    <th>Details</th>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://code.google.com/webtoolkit/">Google Web Toolkit</a></td>
+    <td class="license"><a href="http://code.google.com/webtoolkit/terms.html">Apache License v. 2.0</a></td>
+    <td class="location"><a href="http://code.google.com/webtoolkit/">http://code.google.com/webtoolkit/</a></td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://www.extjs.com/">Ext 2.0</a></td>
+    <td class="license">Ext has <a href="http://extjs.com/license">several licensing options</a> available to fit a variety of needs. LGPL 3.0 is one of them.</td>
+    <td class="location"><a href="http://extjs.com/download">http://extjs.com/download</a></td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://developer.yahoo.com/yui/">Yahoo! User Interface Library (YUI)</a></td>
+    <td class="license"><a href="http://developer.yahoo.com/yui/license.html">BSD</a>.</td>
+    <td class="location"><a href="http://developer.yahoo.com/yui/">http://developer.yahoo.com/yui/</a></td>
+  </tr>
+  <tr>
+    <td class="package"><a href="http://mapstraction.com/">Mapstraction</a></td>
+    <td class="license"><a href="http://en.wikipedia.org/wiki/BSD_license">BSD</a></td>
+    <td class="location"><a href="http://mapstraction.com/">http://mapstraction.com/</a></td>
+  </tr>
+</tbody></table>
+</div>
+</body></html>

 /trunk/lib/gwtext-2.0.5/release_notes.html
 New file
 ,0 → 1,291
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+      <meta http-equiv="content-type" content="text/html; charset=utf-8">
+      <title>GWT-Ext 2.0 Release Notes</title>
+      <style>
+         body {
+            background-color: white;
+            color: #333333;
+            font-family: arial,helvetica,sans-serif;
+            font-size: 12px;
+            margin: 20px;
+         }
+         li {
+            margin-bottom: 0.5em;
+         }
+         li div {
+            margin-top: 0.2em;
+         }
+         code {
+            font-size: medium;
+         }
+      </style></head>
+   <body>
+      <h1>GWT-Ext Release Notes</h1>
+      <ul>
+            <li><a href="#2_0_5">2.0.5</a></li>
+            <li><a href="#2_0_4">2.0.4</a></li>
+            <li><a href="#2_0_3">2.0.3</a></li>
+            <li><a href="#2_0_2">2.0.2</a></li>
+            <li><a href="#2_0_1">2.0.1</a></li>
+            <li><a href="#2_0">2.0</a></li>
+      </ul>
+    <hr/>
+<a name="2_0_5"></a>
+      <h2>Release Notes for GWT-Ext 2.0.5</h2>
+      <p>
+      <h3>Features</h3>
+      <ul>
+        <li><b>Support for <a href="http://code.google.com/p/google-web-toolkit/downloads/list">GWT 1.5.2</a></b>.  A bug introduced by GWT 1.5.2 is having conflict with TreeNode and TreePanel.  GWT has not fixed the problem but if you can't wait for them, we have worked-around it.</li>
+                <li><b>New Widgets: FocusPanel, SyntaxHightlighterPanel, UserCustomCellEditor</b></li>
+      </ul>
+      <h3>Changes</h3>
+      <ul>
+          <li>Various <a target="205bugfixes" href="http://code.google.com/p/gwt-ext/issues/list?can=1&q=status%3AFixed+milestone%3A2_0_5&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary&cells=tiles">Bug Fixes</a></li>
+      </ul>
+      NOTE: if you are using SwfUploadPanel from GWTExtUx 0.3.0, you need to get the latest from SVN or wait until the next build in the next couple of days.  The next build for GWTExtUx will have the anticipated <b>GridTree</b> and GridFilter plugin.
+    <hr/>
+<a name="2_0_4"></a>
+      <h2>Release Notes for GWT-Ext 2.0.4</h2>
+      <p>
+      <h3>Features</h3>
+      <ul>
+        <li><b>Support for <a href="http://code.google.com/p/google-web-toolkit/downloads/list">GWT 1.5 RC1</a></b></li>
+                <li><b>FF3 Support</b></li>
+                <li><b>PageBus</b>
+        <br>
+            Messaging support which allows loosely coupled components to communicate with each other via traditional pubhish / subscribe paradigm. See demo in Showcase under 'Miscellaneous -> Publish Subscribe'
+        </li>
+                <li><b>Eclipse Project Files</b>
+                <br>You can now use GWTExt directly from SVN as an Eclipse project.  You just need to add the <b>GWT_HOME</b> variable to point to the GWT Directory in Eclipse
+                <br>Windows|Preferences|Java|Build Path|Classpath Variables
+        </li>
+      </ul>
+      <h3>Changes</h3>
+      <ul>
+          <li>Various <a target="204bugfixes" href="http://code.google.com/p/gwt-ext/issues/list?can=1&q=status%3AFixed+milestone%3A2_0_4&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary&cells=tiles">Bug Fixes</a></li>
+          <li>Fixed Memory leak when add and remove Panels (Mix of GWT and GWT-Ext)</li>
+      </ul>
+      <h3>GwtExtUx Changes</h3>
+      <ul>
+          <li>FileTreePanel</li>
+          <li>SwfUploadPanel</li>
+          <li>CustomReader</li>
+          <li>Removed individual UX from GwtExtUx.gwt.xml.  This means whenever a
+                        UX is needed, They have to be added individually in the users gwt.xml
+                        file.
+                  </li>
+                  <li>Latest patch in Multiselect.js including memory leak fixes, drag back, etc...</li>
+      </ul>
+    <hr/>
+<a name="2_0_3"></a>
+      <h2>Release Notes for GWT-Ext 2.0.3</h2>
+      <p>
+      <h3>Features</h3>
+      <ul>
+        <li><b>Charts</b>
+        <br>Supports  for Charting via YUI charts. Line, Bar, Pie, Column charts are all available as a standard GWT-Ext Panel subclass. Charts
+            use the standard Store as thier underlying data source. See demo <a href="http://www.gwt-ext.com/demo-charts">here</a>.
+        </li>
+      </ul>
+        <ul>
+        <li><b>Mapping API</b>
+            <br>Supports for Mapping API via Mapstraction. The supported Map providers include OpenStreetMap, Yahoo, Google, Microsoft, Map24,
+            MultiMap, MapQuest, FreeEarth and OpenLayers.
+            <br/>
+            Various Maps are now available as a standard GWT-Ext Panel subclass. The motivation for the GWT-Ext Mapping API is not to compete with the other
+            GWT Google Maps API's which are far more feature rich and complete. This API is over mapstraction which provides several
+            commonly used features such as markers, polylines, GeoRSS and such using the same API.
+            <br/>The desired map provider can be instantiated by a factory, and the rest of the code remains the same and works across various map providers (some free, and others commercial). This gives users more flexibilty to pick a map provider that meets their needs and license requirements.. See demo <a href="http://www.gwt-ext.com/demo-maps">here</a>.
+        </li>
+      </ul>
+        <ul>
+        <li><b>Portal</b>
+            <br>Initial Portal support. See demo here   <a href="http://www.gwt-ext.com/demo/#portal">here</a>
+        </li>
+      </ul>
+      <h3>Changes</h3>
+      <ul>
+          <li>Various Bug Fixes</li>
+          <li>Ext.isFirebug() to detect if Firebug is enabled</li>
+          <li>GridPanel.clearSortState()</li>
+          <li>Support for preserving ordering in PropertyGridPanel</li>
+          <li>com.gwtext.client.widgets.menu.Adapter class to allow and Component (like TextField) to be added to a Menu</li>
+          <li>API's to access various Button's on PagingToolbar</li>
+      </ul>
+    <hr/>
+    <a name="2_0_2"></a>
+      <h2>Release Notes for GWT-Ext 2.0.2</h2>
+      <p>
+      This release supports Ext 2.0.2.
+      <h3>Overview of changes</h3>
+      <ul>
+        <li><b>Label</b>
+        <br>New Form label class
+        </li>
+      </ul>
+        <ul>
+        <li><b>Safari support for Mac hosted mode</b>
+        </li>
+      </ul>
+    <hr/>
+      <a name="2_0_1"></a>
+      <h2>Release Notes for GWT-Ext 2.0.1</h2>
+      <p>
+      This relase has a minor patch release that incorporates a fix to workaround a Safari bug with iframes.
+      <a name="2_0"></a>
+      <h2>Release Notes for GWT-Ext 2.0</h2>
+      <p>
+      This release of GWT-Ext is a new and significantly improved major release that is based on Ext 2.0.
+      <h3>Overview of changes</h3>
+      <ul>
+        <li><b>Performance</b>
+        <br>The overall perfomance and responsiveness has been significantly improved in this release. All components / widgets
+            support lazy rendering which means that they can be instantiated and managed without any overhead and their
+            rendering is deferred to the point at which they are required to be attached to the DOM.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Unified Component model</b>
+        <br>All widgets now follow a consistent hierarchy and are subclasses of a base Component class which manages
+            the creation, rendering and destruction lifecycle operations. Methods common to all Components are now easily
+            accessible in a consistent, intuitive and easy to use manner. Containers, which also extends the Component class,
+            can contain other child components which can be one of the many available widgets or another child Container.
+            Containers only know about the child Components that are added to them, and their layout responsibilities are
+            delegated to the assigned LayoutManager. The Panel class is a subclass of Container and is typically the class
+            users will work with. The Panel class adds a lot of useful features like header, top toolbar, bottom toolbar,
+            and ability to collapse and expand.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Improved Layout management</b>
+        <br>Building complex layouts in earlier versions was a little cumbersome but it is now a thing of the past. This version
+            has an architecture that separates the responsibility of Containers, which are only aware of child Components, and the
+            layout of the Components within the Container which is handled by an assigned LayoutManager. There are several
+            powerful yet easy to use layouts available like BorderLayout, AccordionLayout, VerticalLayout, HorizontalLayout,
+            AnchorLayout, TableLayout and others that make building complex layouts quite trivial.
+            The Showcase demo has examples of variouos layouts in action.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Bean friendly API's and better support for extension</b>
+        <br>Separate config classes associated with a widget are no longer required. All Components support a default / no-op
+            constructor and getters and setter for various properties. Various Components do have additional relevant convenience
+            constructors that are frequently used during development like assigning a label and an action listener to a Button.
+            In this version users can now extend any Component, add members and methods and it will be passed by reference when
+            accessed through a callback or a lookup. In short, things work as expected in a typical Java environment.
+        </li>
+      </ul>
+      <hr/>
+      <h3>Features</h3>
+      Many features of the library are illustrated in the Showcase demo. The Showcase demo is <a href="samples/Showcase2/www/com.gwtext.sample.showcase2.Showcase2/Showcase2.html" target="_blank">bundled</a> with the distribution
+      and can also be accessed online from the <a href="http://www.gwt-ext.com">project page</a>.
+      <ul>
+        <li><b>Grid</b>
+        <br>The performance has been significantly improved in this release and the Grid component can render a large number
+            of rows very fast. The GridPanel now supports Single Level Row Grouping, Grouping of Summary Rows, List box look,
+            drag and drop capabilities, checkbox and row numbered column, context menus and a lot more features.
+            Support for Grid to Tree drag and drop has also been added.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Tree</b>
+        <br>The TreePanel component supports Checkbox nodes, Drag n Drop between trees and from a grid to a tree, sorting,
+            filtering multi select and many other features. It also handles display of large number of nodes efficiently.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Forms</b>
+        <br>Forms have been improved significantly allowing users ultimate flexibility in adding and arranging Fields and
+            other Components. For example multiple fields on a single row, fields displayed across tabs, Grids or even
+            Images in a form and other configurations that were previously not easy to setup.
+        </li>
+      </ul>
+      <ul>
+        <li><b>TabPanels</b>
+        <br>TabPanel's now support scrollable tabs (like Firefox) and context menu's. They support deferred tab rendering
+            so that a tab's content is rendered only when the user selects the tab. Adding IFrames to tabs is also supported.
+        </li>
+      </ul>
+      <ul>
+        <li><b>DataView</b>
+        <br>DataView is a powerful class that allows you to specify a template for rendering a given Record. You can
+            then bind the DataView to a Store and it will render the Records using the specified HTML template. It not
+            only renders the content but is also backed by a rich event model which allows you to have full control over
+            user actions like click, context menu, double click etc. The main page of the Showcase demo uses a DataView
+            to display the thumbnail images of the samples.
+        </li>
+      </ul>
+      <ul>
+        <li><b>Windows</b>
+        <br>A Window is a specialized Panel that supports floating, dragging, minimize/maximize/restore. Any other
+            Container or Component can be added to a Window as illustrated by various examples in the Showcase demo.
+        </li>
+      </ul>
+      <h3>New Widgets</h3>
+      <ul>
+        <li><b>Accordion</b>
+        <br>An Accordion is simply a Container that is assigned an AccordionLayout. All child Panel's
+            added to it will be laid out in the form of an Accordion. And since any Contaienr can be added to a Window,
+            creating a floatable Accordion is a breeze.
+        </li>
+      </ul>
+      <ul>
+        <li><b>ProgressBar</b>
+        <br>Highly configurable ProgressBar and support for custom styling.
+        </li>
+      </ul>
+         <ul>
+        <li><b>Tooltips</b>
+        <br>Powerful and easy to use Tooltips that can be applied to any Component. Also supports loading
+            remote tooltip content using Ajax.
+        </li>
+        </ul>
+         <ul>
+        <li><b>CycleButton</b>
+        <br>This is a specialized Menu Button that contains a menu of CheckItem's. The button automatically cycles
+            through each menu item when clicked.
+        </li>
+        </ul>
+         <ul>
+        <li><b>TimeField</b>
+        <br>A field that has a dropdown with a time picker.
+        </li>
+        </ul>
+         <ul>
+        <li><b>Hidden Field</b>
+        <br>Ability to add a hidden input field to a Form.
+        </li>
+        </ul>
+    <hr/>
+      <h3>GWT-Plus compatibility</h3>
+      <ul>
+        <li><a href="http://gwtplus.gwt-ext.com/">GWT-Plus</a> is fully compatible with GWT-Ext 2.0.
+        </li>
+      </ul>
+   </body></html>

 /trunk/lib/gwtext-2.0.5/about.html
 New file
 ,0 → 1,64
+<html>
+   <head>
+      <title>GWT-Ext 2.0.2</title>
+      <style>
+         body {
+            background-color: white;
+            color: black;
+            font-family: Arial, sans-serif;
+            font-size: 10pt;
+            margin: 20px;
+            overflow: hidden;
+         }
+         #title {
+            font-size: 14pt;
+            font-weight: bold;
+         }
+         #title a {
+            text-decoration: none;
+         }
+         #version {
+            font-size: 8pt;
+            font-weight: bold;
+            text-align: right;
+         }
+         #intro {
+            margin: 10px 0px 10px 0px ;
+         }
+         #attribs {
+         }
+      </style>
+   </head>
+   <body>
+      <table align="center">
+         <tr>
+            <td id="title"><a href="http://www.gwt-ext.com/">GWT-Ext</a></td>
+         </tr>
+         <tr>
+            <td id="version">Version 2.0.2</td>
+         </tr>
+      </table>
+      <hr/>
+      <div id="attribs">
+         This product uses software developed by
+         <ul>
+            <li>The <a href="http://code.google.com/webtoolkit">Google Web Toolkit (GWT) Project</a></li>
+            <li>The <a href="http://www.extjs.com/">Ext Project</a></li>
+         </ul>
+         For source availability and license information see COPYING.html.
+      </div>
+   </body>
+</html>

/trunk/lib/gwtext-2.0.5/gwtext.jar
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/lib/gwt-maps-3.8.0/COPYING
 New file
 ,0 → 1,176
+       GOOGLE API LIBRARY FOR GOOGLE WEB TOOLKIT LICENSE INFORMATION
+May 30, 2007
+The Google API Library for Google Web Toolkit software and sample code developed
+by Google is licensed under the Apache License, v. 2.0.  Source code for
+software included in this distribution is available from the Google API Library
+for Google Web Toolkit project.
+This distribution contains code from the Xerces library
+licensed under the Apache License, v. 2.0 and
+available from http://xerces.apache.org.
+=====
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+. Definitions.
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of
+such entity.
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+"Object" form shall mean any form resulting from mechanical transformation
+or translation of a Source form, including but not limited to compiled
+object code, generated documentation, and conversions to other media types.
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on (or derived from) the Work and for which the editorial
+revisions, annotations, elaborations, or other modifications represent, as a
+whole, an original work of authorship. For the purposes of this License,
+Derivative Works shall not include works that remain separable from, or
+merely link (or bind by name) to the interfaces of, the Work and Derivative
+Works thereof.
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner. For the
+purposes of this definition, "submitted" means any form of electronic,
+verbal, or written communication sent to the Licensor or its
+representatives, including but not limited to communication on electronic
+mailing lists, source code control systems, and issue tracking systems that
+are managed by, or on behalf of, the Licensor for the purpose of discussing
+and improving the Work, but excluding communication that is conspicuously
+marked or otherwise designated in writing by the copyright owner as "Not a
+Contribution."
+"Contributor" shall mean Licensor and any individual or Legal Entity on
+behalf of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in
+this section) patent license to make, have made, use, offer to sell, sell,
+import, and otherwise transfer the Work, where such license applies only to
+those patent claims licensable by such Contributor that are necessarily
+infringed by their Contribution(s) alone or by combination of their
+Contribution(s) with the Work to which such Contribution(s) was submitted.
+If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this
+License for that Work shall terminate as of the date such litigation is
+filed.
+. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and
+in Source or Object form, provided that You meet the following conditions:
+a. You must give any other recipients of the Work or Derivative Works a copy
+of this License; and
+b. You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+c. You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from
+the Source form of the Work, excluding those notices that do not pertain to
+any part of the Derivative Works; and
+d. If the Work includes a "NOTICE" text file as part of its distribution,
+then any Derivative Works that You distribute must include a readable copy
+of the attribution notices contained within such NOTICE file, excluding
+those notices that do not pertain to any part of the Derivative Works, in at
+least one of the following places: within a NOTICE text file distributed as
+part of the Derivative Works; within the Source form or documentation, if
+provided along with the Derivative Works; or, within a display generated by
+the Derivative Works, if and wherever such third-party notices normally
+appear. The contents of the NOTICE file are for informational purposes only
+and do not modify the License. You may add Your own attribution notices
+within Derivative Works that You distribute, alongside or as an addendum to
+the NOTICE text from the Work, provided that such additional attribution
+notices cannot be construed as modifying the License.
+You may add Your own copyright statement to Your modifications and may
+provide additional or different license terms and conditions for use,
+reproduction, or distribution of Your modifications, or for any such
+Derivative Works as a whole, provided Your use, reproduction, and
+distribution of the Work otherwise complies with the conditions stated in
+this License.
+. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without
+any additional terms or conditions. Notwithstanding the above, nothing
+herein shall supersede or modify the terms of any separate license agreement
+you may have executed with Licensor regarding such Contributions.
+. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor, except
+as required for reasonable and customary use in describing the origin of the
+Work and reproducing the content of the NOTICE file.
+. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any
+warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining
+the appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+. Limitation of Liability. In no event and under no legal theory, whether
+in tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to
+in writing, shall any Contributor be liable to You for damages, including
+any direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or inability
+to use the Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all other
+commercial damages or losses), even if such Contributor has been advised of
+the possibility of such damages.
+. Accepting Warranty or Additional Liability. While redistributing the Work
+or Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any
+liability incurred by, or claims asserted against, such Contributor by
+reason of your accepting any such warranty or additional liability.

/trunk/lib/gwt-maps-3.8.0/gwt-maps.jar
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/lib/gwt-maps-3.8.0/README.txt
 New file
 ,0 → 1,139
+Google Maps V3 Bindings for GWT
+This software is distributed under the Apache 2.0 license.
+See the file COPYING for more details.
+For more information on this project, see:
+  http://code.google.com/p/gwt-google-apis
+Contents:
+  gwt-maps-<version>.jar  Add this library to your GWT project
+  javadoc/                Javadoc generated from the API
+  samples/                Short examples that show how to use the API.
+For support, try the gwt-google-apis Google group.
+If you think you have found a bug, see the online Issue tracker
+==================================================================
+Instructions for using Eclipse
+These instructions require
+  GWT 2.4 or higher          http://code.google.com/webtoolkit
+  Google Plugin for Eclipse  http://code.google.com/eclipse
+  Java JDK 1.5 or higher     http://java.sun.com/
+---------- General Instructions  ---------------------------------
+To work with the API in Eclipse, First create a 'Web Application' project
+using the Google Plugin for Eclipse with Google Web Toolkit enabled.
+This should create a new directory in your workspace for the project and
+a war/WEB-INF/lib directory.  The gwt-maps.jar file need to be copied there
+then refresh your project in Eclipse.
+In Eclipse, add the gwt-maps.jar file to the build path, for example:
+Project
+  -> Properties
+    -> Java Build Path
+      -> Libraries
+        -> Select gwt-maps.jar
+Next, open to your entry point's .gwt.xml file and add the line:
+  <inherits name="com.google.maps.gwt.GoogleMaps" />
+Finally, you need to do one of two things to load the API on
+application startup:
+) Update your host file to include the following script tag:
+  <script type="text/javascript" src="http://maps.googleapis.com/maps/api/js?sensor=SENSOR_TRUE_OR_FALSE"></script>
+  Where the sensor value is either "true" or "false" depending on if you
+  are hooked up to a location sensing device.  See the Maps API documentation
+  at http://developers.google.com/maps/documentation/javascript/tutorial
+) Load the API through the AjaxLoader library.  See the sample
+  "MapsSimpleAjaxLoader.java" for an example.  The AjaxLoader library is
+  bundled with the gwt-maps.jar distribution.  You will need to add
+  the following line to your gwt module definition:
+  <inherits name="com.google.gwt.ajaxloader.AjaxLoader" />
+---------- Running a Sample ----------------------------------------
+These instructions describe how to take one of the distributed samples
+and run them in Eclipse using GWT's DevMode.  This assumes you are already
+configured Eclipse with the Google Plugin for Eclipse and have run
+through the GWT tutorials before.
+Start by create a new Web Application Project. Uncheck the checkbox box to
+install template code so that you start with an empty project.
+Recursively copy in the sample code into the 'src' directory of your new
+project.  Your src tree should now have the directories
+com/google/maps/gwt/samples/...
+Add the gwt-maps.jar to war/WEB-INF/lib and add it to the Java build path
+of your project as mentioned in "General Instructions" above.
+Choose the sample you'd like to run.  We'll use MapGeolocation.java as an
+example.
+Find MapGeolocoation.java in the tree, then find the corresponding .html file
+for it in one of the 'public' directories.  In this case its
+'map_geolocation.html'.
+Copy the .html file down into the 'war' directory.
+Open up the .html file and look at the module name.  To be compatible
+with the Google Plugin for Eclipse, you'll need to edit the src attribute
+'map_geolocation.nocache.js' and prepend the module name:
+      <script type="text/javascript" language="javascript"
+       src="map_geolocation/map_geolocation.nocache.js"></script>
+Next, you'll need to create a GWT module
+) Create a new GWT module using:
+   File
+     --> New
+       --> Other...
+         --> Google Web Toolkit
+           --> Module
+) Choose the module name to match the name in the .html file. In our
+     example, that would be map_geolocation.  The package should be one
+     level up from the location of the .java file:
+     Package: com.google.maps.gwt.samples.basics
+     Module name: map_geolocation
+     Inherited Modules: com.google.gwt.user.User
+                        com.google.maps.gwt.GoogleMaps
+) Open the new module and add make the following modifications:
+     Add a 'rename-to' attribute to the module start tag
+     <module rename-to="map_geolocation" />
+     Add in the .java sample as an entry point
+     <entry-point
+      class="com.google.maps.gwt.samples.basics.client.MapGeolocation" />
+Finally, you are ready to launch the sample!  Right click on the
+new map_geolocation.gwt.xml module and run the sample:
+  Run As
+   --> Web Application
+Choose the web page you copied down (map_gelocation.html)  if prompted.

 /trunk/local.default.properties
 New file
 ,0 → 1,14
+# écrase les valeurs de build.properties avec votre config locale
+# Pour l'URL de l'appli dans le mode hosted
+#cel-host = localhost
+#cel-base-url = war/cel2.html
+# note: les répertoires de gwt, gwt-google-api, gwtext et gwtextux sont fixé relatif à ${gwt-path} dans build.xml
+#gwt-path = ${user.home}/gwt
+#gwt-maps-path = lib/gwt-maps-3.8.0
+#gwt-ext-path = lib/gwtext-2.0.5
+#gwt-ext-ux-path = lib/gwtextux-0.3
+# doit contenir ext-all.js, resources et adapter/ext/ext-base.js
+#ext-js-dir = vendors/extjs-2.0.1

Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 3944 → Rev 3943