WebSVN – eFlore/Applications.cel – Path Comparison – / – /trunk/src/org/tela_botanica/ Rev HEAD and /trunk/src/org/tela

Ignore whitespace Rev HEAD → Rev 33

 /trunk/src/org/tela_botanica/cel2.gwt.xml
 New file
 ,0 → 1,34
+<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' />
+                <!-- Encore des trucs pour les user extensions -->
+                <inherits name='com.gwtextux.GwtExtUx'/>
+                <stylesheet src="js/ext/resources/css/ext-all.css" />
+                <script src="js/ext/adapter/ext/ext-base.js" />
+                <script src="js/ext/ext-all.js" />
+                <script src="js/UploadDialog/Ext.ux.UploadDialog.js" />
+                <script src="js/UploadDialog/Ext.ux.UploadDialog.packed.js" />
+      <!-- Specify the app entry point class.                         -->
+      <entry-point class='org.tela_botanica.client.cel2'/>
+      <!-- Specify the application specific style sheet.              -->
+      <stylesheet src='cel2.css' />
+</module>

 /trunk/src/org/tela_botanica/client/modeles/UtilisateurAsynchroneDAO.java
 New file
 ,0 → 1,181
+package org.tela_botanica.client.modeles;
+/**
+ * Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
+ *
+ */
+import org.tela_botanica.client.CarnetEnLigneModele;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import 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.json.client.JSONArray;
+import com.google.gwt.json.client.JSONBoolean;
+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.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+public class UtilisateurAsynchroneDAO {
+        /**
+         * Le modèle associé au DAO
+         */
+        private CarnetEnLigneModele carnetEnLigneModele = null ;
+        /**
+         * Constructeur
+         */
+        public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) {
+                this.carnetEnLigneModele=carnetEnLigneModele;
+        }
+        /**
+         * Methode de classe d'appel du service gestion identification
+         * @param baseURL : URL du service
+         * @param retour : methode appelle en retour d'appel
+         */
+        public void getEtatUtilisateur(final Rafraichissable r) {
+                // Recherche identifiant utilisateur identifie
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,carnetEnLigneModele.getConfig().getServiceBaseUrl() + "/User/") ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        JSONValue jsonValue = JSONParser.parse(response.getText());
+                                        JSONArray jsonArray;
+                                        if ((jsonArray = jsonValue.isArray()) != null) {
+                                                String identifiant = ((JSONString) jsonArray.get(0))
+                                                                .stringValue(); // Identifiant utilisateur ou
+                                                                                                // identifiant de session si non
+                                                                                                // identifie
+                                                boolean identifie = ((JSONBoolean) jsonArray.get(1))
+                                                                .booleanValue(); // Drapeau leve si utilisateur
+                                                                                                        // deja identifie
+                                                r.rafraichir(new Utilisateur(identifiant, identifie),true);
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+        public void deconnecterUtilisateur(final Rafraichissable r, String user) {
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, carnetEnLigneModele.getConfig().getServiceBaseUrl()+ "/User/" + user) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        JSONValue jsonValue = JSONParser.parse(response.getText());
+                                        JSONArray jsonArray;
+                                        if ((jsonArray = jsonValue.isArray()) != null) {
+                                                String identifiant = ((JSONString) jsonArray.get(0))
+                                                .stringValue(); // Identifiant utilisateur ou
+                                                                                // identifiant de session si non
+                                                                                // identifie
+                                                boolean identifie = ((JSONBoolean) jsonArray.get(1))
+                                                .booleanValue(); // Drapeau leve si utilisateur
+                                                                                        // deja identifie
+                                        r.rafraichir(new Utilisateur(identifiant, identifie),true);
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                }
+        }
+        public void connecteUtilisateur (final Rafraichissable r, String login, String password) {
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,carnetEnLigneModele.getConfig().getServiceBaseUrl() + "/User/" + login + "/" + password) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        JSONValue jsonValue = JSONParser.parse(response.getText());
+                                        JSONArray jsonArray;
+                                        if ((jsonArray = jsonValue.isArray()) != null) {
+                                                String identifiant = ((JSONString) jsonArray.get(0))
+                                                .stringValue(); // Identifiant utilisateur ou
+                                                                                // identifiant de session si non
+                                                                                // identifie
+                                                boolean identifie = ((JSONBoolean) jsonArray.get(1))
+                                                .booleanValue(); // Drapeau leve si utilisateur
+                                                                                        // deja identifie
+                                                r.rafraichir(new Utilisateur(identifiant, identifie),true);
+                                        }
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        e.printStackTrace() ;
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ReferentielCommune.java
 New file
 ,0 → 1,47
+package org.tela_botanica.client.modeles;
+/**
+ *
+ * Classe representant un element du referentiel commune ou localite
+ *
+ */
+public class ReferentielCommune {
+        private String commune=null;
+        private String departement=null;
+        public ReferentielCommune() {
+        }
+        /**
+         * @param commune
+         * @param departement
+         */
+        public ReferentielCommune(String commune, String departement) {
+                this.commune = commune;
+                this.departement = departement;
+        }
+        public String getCommune() {
+                return commune;
+        }
+        public String getDepartement() {
+                return departement;
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/modeles/ListeReferentielCommune.java
 New file
 ,0 → 1,53
+package org.tela_botanica.client.modeles;
+import java.util.HashMap;
+/**
+ * table de hachage composée de communes, renvoyé par les objets de type DAO
+ * pour les communes
+ * TODO : utiliser un identifiant commune
+ * La clé est le nom de la commune + l'identifiant du departement de la commune dans la base de données, et la valeur un objet
+ * de type ReferentielCommune
+ * @author david delon
+ *
+ */
+public class ListeReferentielCommune extends HashMap<String, ReferentielCommune> {
+        private static final long serialVersionUID = 2714510270773281540L;
+        /**
+         * Constructeur sans paramètres
+         */
+        public ListeReferentielCommune()
+        {
+                super();
+        }
+        /**
+         * Constructeur avec paramètre
+         * @param taille la taille de la table de hachage
+         */
+        public ListeReferentielCommune(int taille)
+        {
+                super(taille);
+        }
+        /**
+         * Constructeur avec paramètre
+         * @param ic un tableau d'ImageCarnet
+         */
+        public ListeReferentielCommune(ReferentielCommune[] com)
+        {
+                super() ;
+                for (int i = 0; i < com.length; i++)
+                {
+                        if(com[i] != null && com[i] instanceof ReferentielCommune)
+                        {
+                                this.put(com[i].getCommune()+com[i].getDepartement(),com[i]);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/Observation.java
 New file
 ,0 → 1,144
+package org.tela_botanica.client.modeles;
+public class Observation {
+        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;
+        public Observation() {
+        }
+        /**
+         * @param transmis
+         * @param nomSaisi
+         * @param nomRetenu
+         * @param numeroNomenclaturalSaisi
+         * @param numeroNomenclaturalRetenu
+         * @param numeroTaxonomique
+         * @param famille
+         * @param localite
+         * @param IdentifiantLocalite
+         * @param lieudit
+         * @param station
+         * @param milieu
+         * @param commentaire
+         * @param date
+         * @param numeroOrdre
+         */
+        public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclaturalSaisi,  String numeroNomenclaturalRetenu, String numeroTaxonomique, String famille, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) {
+                this.transmis = transmis;
+                this.nomSaisi = nomSaisi;
+                this.nomRetenu = nomRetenu;
+                this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi;
+                this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu;
+                this.numeroTaxonomique = numeroTaxonomique;
+                this.famille = famille;
+                this.localite = localite;
+                this.identifiantLocalite = identifiantLocalite;
+                this.lieudit = lieudit;
+                this.station = station;
+                this.milieu = milieu;
+                this.commentaire = commentaire;
+                this.date = date;
+                this.numeroOrdre = numeroOrdre;
+        }
+        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() {
+                return identifiantLocalite;
+        }
+        public String getMilieu() {
+                return milieu;
+        }
+        public String getNomRetenu() {
+                return nomRetenu;
+        }
+        public String getNumeroNomenclaturalSaisi() {
+                return numeroNomenclaturalSaisi;
+        }
+        public String getNumeroNomenclaturalRetenu() {
+                return numeroNomenclaturalRetenu;
+        }
+        public String getNumeroTaxonomique() {
+                return numeroTaxonomique;
+        }
+        public String getStation() {
+                return station;
+        }
+        public String getTransmis() {
+                return transmis;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java
 New file
 ,0 → 1,163
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.image.ImageModele;
+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)
+         */
+        @SuppressWarnings("unused")
+        private static void appelerUploadSimple() {
+                UploadDialog up = new UploadDialog("Upload simple de fichiers");
+                up.setUrl(iModele.getConfig().getServiceBaseUrl() + "/InventoryImage");
+                UrlParam id = new UrlParam("identifiant", iModele.getIdentifiant());
+                UrlParam[] params = { id };
+                up.setBaseParams(params);
+                up.setModal(true);
+                up.addListener(new UploadDialogListenerAdapter() {
+                        public void onClose(Panel panel) {
+                                iModele.requeteTerminee();
+                        }
+                        public void onUploadComplete(UploadDialog source) {
+                                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)
+         */
+        @SuppressWarnings("unused")
+        private static void appelerUploadMultiple() {
+                final Window nPan = new Window("Upload multiple");
+                nPan.setWidth(640);
+                final String warning = "<p class=\"warning_upload\"> A la fin de l'envoi, veuillez fermer la fenêtre pour accéder aux images. </p>";
+                final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" archive=\"wjhk.jupload.jar\" alt=\"\" mayscript=\"\" height=\"350\" width=\"625\">";
+                final String paramPostTarget = "<param name=\"postURL\" value=\""
+                                + iModele.getConfig().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=\"10000000\">";
+                final String paramTransmitMetaData = "<param name=\"pictureTransmitMetadata\" value=\"true\">";
+                final String paramFilesPerRequest = "<param name=\"nbFilesPerRequest\" value=\"1\">";
+                final String paramAllowedExtensions = "<param name=\"allowedFileExtensions\" value=\"jpg/jpeg/\">";
+                final String paramUploadSuccess = "<param name=\"stringUploadSuccess\" value=\"OK\">";
+                final String paramShowLogWindow = "<param name=\"showLogWindow\" value=\"false\">";
+                final String paramFormdata = "<param name=\"formData\" value=\"postid\">";
+                final String finApplet = "</applet>";
+                final String appelApplet = applet + paramPostTarget + paramUploadPolicy
+                                + paramMaxChunkSize + paramMaxFileSize + paramTransmitMetaData
+                                + paramFilesPerRequest + paramAllowedExtensions
+                                + paramUploadSuccess + paramShowLogWindow + paramFormdata
+                                + finApplet;
+                final String htmlForm = "<form method=\"post\" name=\"postid\">"
+                                + "<input type=\"hidden\" name=\"identifiant\" value=\""
+                                + iModele.getIdentifiant() + "\">" + "</form>";
+                nPan.setHtml(warning + appelApplet + htmlForm);
+                nPan.setModal(true);
+                nPan.addListener(new WindowListenerAdapter() {
+                        public void onClose(Panel panel) {
+                                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.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ;
+          }
+          else
+          {
+                @org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ;
+          }
+        }-*/;
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeObservation.java
 New file
 ,0 → 1,50
+package org.tela_botanica.client.modeles;
+import java.util.HashMap;
+/**
+ * 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
+ * GWT ne supporte pas encore les type paramètres mais quand il le fera il faudra créer la HashMap
+ * avec <String,Observation>
+ * @author david delon
+ *
+ */
+public class ListeObservation extends HashMap {
+        /**
+         * 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]);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeReferentielNomAsynchroneDAO.java
 New file
 ,0 → 1,119
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.Util;
+import org.tela_botanica.client.interfaces.FournisseurListe;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationModele;
+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.json.client.JSONArray;
+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.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+/**
+ * DAO  liste noms scientifiques
+ * @author David Delon
+ *
+ */
+public class ListeReferentielNomAsynchroneDAO implements FournisseurListe {
+        /**
+         * Le modèle associé au DAO
+         */
+        private ObservationModele observationModele = null ;
+        public ListeReferentielNomAsynchroneDAO(ObservationModele observationModele)
+        {
+                this.observationModele=observationModele;
+        }
+        /**
+         * Envoie une requete au serveur jrest pour obtenir les communes  correspondant
+         * à des critères données en paramètres
+         * @param r le rafraichissable qui demande la mise à jour
+         * @param criteres un string contenant le terme a rechercher
+         */
+        public void obtenirListeDonnees(final Rafraichissable r, String critere)
+        {
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, observationModele.getConfig().getServiceBaseUrl()+"/NameSearch/"+critere) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        final ListeReferentielNom referentielNomData ;
+                                        final JSONValue responseValue = JSONParser.parse(response.getText());
+                                        JSONArray reponse=null;
+                                        // si c'est un tableau
+                                        if ((reponse=responseValue.isArray()) != null) {
+                                                JSONArray noms;
+                                                final int taillemax = reponse.size();
+                                                referentielNomData = new ListeReferentielNom(taillemax);
+                                                for (int i = 0; i < taillemax; i++) {
+                                                        if ((noms=reponse.get(i).isArray()) != null) {
+                                                                String nom=Util.toCelString(((JSONString) noms.get(0)).toString());
+                                                                String numeroNom=Util.toCelString(((JSONString) noms.get(1)).toString());
+                                                                ReferentielNom nomScientifique=new ReferentielNom(nom, numeroNom);
+                                                                // FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....)
+                                                                referentielNomData.put(nomScientifique.getNumeroNom(),nomScientifique);
+                                                        }
+                                                }
+                                        } else {
+                                                referentielNomData = new ListeReferentielNom(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(referentielNomData,true);
+                                }
+                        }) ;
+                } catch(RequestException e) {
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ImageAsynchroneDAO.java
 New file
 ,0 → 1,173
+package org.tela_botanica.client.modeles;
+import java.util.Iterator;
+import org.tela_botanica.client.image.ImageModele;
+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;
+/**
+ * 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 = "";
+                // on construit le post avec toutes les valeur de l'image
+                for (Iterator<String> imgIt = ic.keySet().iterator(); imgIt.hasNext();) {
+                        String key = imgIt.next();
+                        String valeur = ic.renvoyerValeurCorrecte(key);
+                        postData += "&" + key + "=" + valeur;
+                }
+                // et on envoie une requête asynchrone
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImage/" + iModele.getIdentifiant() + "/");
+                try {
+                        rb.sendRequest(postData, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        if (response.getText().equals("OK")) {
+                                                return;
+                                        } else {
+                                                com.google.gwt.user.client.Window
+                                                                .alert("Problème lors de la mise à jour des données");
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        /**
+         * Met à jour la base de données avec les mots clés associés à l'image
+         *
+         * @param ic
+         *            l'image à mettre à jour
+         */
+        public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) {
+                String postData = "";
+                // on récupère les mots clés de l'image et on fabrique le post
+                String motsCles = ic.getMotsCles();
+                String id = ic.getId();
+                postData += "&ci_id_image=" + id + "&ci_meta_mots_cles=" + motsCles;
+                // on envoie une requête asynchrone
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImage/" + iModele.getIdentifiant() + "/");
+                try {
+                        rb.sendRequest(postData, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        if (response.getText().equals("OK")) {
+                                                return;
+                                        } else {
+                                                com.google.gwt.user.client.Window
+                                                                .alert("Problème lors de la mise à jour des données");
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        /**
+         * Supprime 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
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImage/"
+                                + iModele.getIdentifiant()
+                                + "/"
+                                + ic.getId());
+                try {
+                        rb.sendRequest(postData, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        if (response.getText().equals("OK")) {
+                                                return;
+                                        } else {
+                                                com.google.gwt.user.client.Window
+                                                                .alert("Problème lors de la mise à jour des données");
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java
 New file
 ,0 → 1,250
+package org.tela_botanica.client.modeles;
+import java.util.Iterator;
+import org.tela_botanica.client.image.ImageModele;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+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.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
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/InventoryImageList/"
+                                + iModele.getIdentifiant()
+                                + "/"
+                                + requete);
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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());
+                        // pour chaque image on extrait les informations
+                        for (Iterator<String> imgIt = enCours.keySet().iterator(); imgIt
+                                        .hasNext();) {
+                                // qu'on place dans le poste
+                                String key = imgIt.next();
+                                String valeur = enCours.renvoyerValeurCorrecte(key);
+                                valeur.replaceAll("'", "\'");
+                                postData += "&" + key + "="
+                                                + enCours.renvoyerValeurCorrecte(key);
+                        }
+                        // on fait un post asynchrone et on les envoie à jrest
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                        .getConfig().getServiceBaseUrl()
+                                        + "/inventoryImage/" + iModele.getIdentifiant() + "/");
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                if (response.getText().equals("OK")) {
+                                                        return;
+                                                } else {
+                                                        com.google.gwt.user.client.Window
+                                                                        .alert("Problème lors de la mise à jour des données");
+                                                }
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+        /**
+         * Supprime des image sur le serveur par rapport à leur identifant
+         *
+         * @param ids
+         *            un tableau d'identifiants d'images à supprimer
+         */
+        public void supprimerBaseDeDonnees(String[] ids) {
+                String postData = "";
+                // on fait un delete dans le post (jrest ne gère pas delete comme une
+                // action à part entière)
+                postData += "&action=DELETE";
+                String uid = "";
+                // on concatène les ids
+                for (int i = 0; i < ids.length; i++) {
+                        uid += ids[i] + ",";
+                }
+                // et on envoie ça au serveur
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImageList/" + iModele.getIdentifiant() + "/" + uid);
+                try {
+                        rb.sendRequest(postData, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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/NombreImageAsynchroneDAO.java
 New file
 ,0 → 1,113
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.image.ImageModele;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+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.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
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/InventoryImageCount/"
+                                + iModele.getIdentifiant()
+                                + "/"
+                                + requete);
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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.isArray() != null) {
+                                                // qui contient une valeur : le nombre d'images
+                                                // correspondant au critères
+                                                JSONValue res = responseValue.isArray().get(0);
+                                                JSONString reponseNombre = res.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/Configuration.java
 New file
 ,0 → 1,40
+package org.tela_botanica.client.modeles;
+import com.google.gwt.i18n.client.Dictionary;
+/**
+ * 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 String serviceBaseUrl;
+        private String imageBaseUrl;
+        /**
+         * Constructeur sans argument
+         */
+        public Configuration() {
+                // on utilise le dictionnaire d'internationalisation pour lire les
+                // variables du fichier javascript
+                serviceBaseUrl = Dictionary.getDictionary("configuration").get(
+                                "serviceBaseUrl");
+        }
+        /**
+         * Accesseur pour l'url de base du serveur jrest
+         *
+         * @return une url de la forme http://emplacement_serveur/jrest
+         */
+        public String getServiceBaseUrl() {
+                return serviceBaseUrl;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeReferentielCommuneAsynchroneDAO.java
 New file
 ,0 → 1,127
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.Util;
+import org.tela_botanica.client.interfaces.FournisseurListe;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationModele;
+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.json.client.JSONArray;
+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.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+/**
+ * DAO la liste des communes
+ * @author David Delon
+ *
+ */
+public class ListeReferentielCommuneAsynchroneDAO implements FournisseurListe {
+        /**
+         * Le modèle associé au DAO
+         */
+        private ObservationModele observationModele = null ;
+        public ListeReferentielCommuneAsynchroneDAO(ObservationModele observationModele)
+        {
+                this.observationModele=observationModele;
+        }
+        /**
+         * Envoie une requete au serveur jrest pour obtenir les communes  correspondant
+         * à des critères données en paramètres
+         * @param r le rafraichissable qui demande la mise à jour
+         * @param criteres un string contenant le terme a rechercher
+         */
+        public void obtenirListeDonnees(final Rafraichissable r, String critere)
+        {
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,observationModele.getConfig().getServiceBaseUrl()+"/LocationSearch/"+critere) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        final ListeReferentielCommune referentielCommuneData ;
+                                        final JSONValue responseValue = JSONParser.parse(response.getText());
+                                        JSONArray reponse=null;
+                                        // si c'est un tableau
+                                        if ((reponse=responseValue.isArray()) != null) {
+                                                JSONArray communes;
+                                                final int taillemax = reponse.size();
+                                                referentielCommuneData = new ListeReferentielCommune(taillemax);
+                                                for (int i = 0; i < taillemax; i++) {
+                                                        if ((communes=reponse.get(i).isArray()) != null) {
+                                                                String commune=((JSONString) communes.get(0)).stringValue();
+                                                                String departement=((JSONString) communes.get(1)).stringValue();
+                                                                ReferentielCommune com=new ReferentielCommune(commune, departement);
+                                                                referentielCommuneData.put(com.getCommune()+com.getDepartement(),com);
+                                                        }
+                                                }
+                                        } else {
+                                                referentielCommuneData = new ListeReferentielCommune(0) ;
+                                        }
+                                        // 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(referentielCommuneData,true);
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        e.printStackTrace() ;
+                }
+                // on envoie le get asynchrone
+                HTTPRequest.asyncGet(observationModele.getConfig().getServiceBaseUrl()+"/LocationSearch/"+critere, new ResponseTextHandler() {
+                        // si tout se passe bien on reçoit une réponse JSON
+                        public void onCompletion(String responseText) {
+                    }
+                });
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/MotsClesAsynchroneDAO.java
 New file
 ,0 → 1,248
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.image.ImageModele;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+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.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 {
+        /**
+         * Le modele associé au DAO
+         */
+        private ImageModele iModele = null;
+        public MotsClesAsynchroneDAO(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 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
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/InventoryKeyWordList/" + iModele.getIdentifiant());
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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);
+                                        }
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        /**
+         * Envoie requete au serveur jrest pour ajouter un mot clé
+         *
+         * @param motcle
+         *            le mots clés à ajouter avec son parent et son identifiant
+         */
+        public void ajouterBaseDeDonnees(String motcle) {
+                if (!motcle.equals("")) {
+                        String postData = motcle;
+                        // on fait un post asynchrone
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                        .getConfig().getServiceBaseUrl()
+                                        + "/InventoryKeyWordList/");
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                // si on reçoit une erreur d'ajout, on affiche un
+                                                // message d'erreur
+                                                if (response.getText().equals("ERROR")) {
+                                                        Window
+                                                                        .alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application,"
+                                                                                        + "nous vous invitons à recharger la page. ");
+                                                }
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+        /**
+         * Envoie requete au serveur jrest pour supprimer un mot clé
+         *
+         * @param motcle
+         *            le mots clés à supprimer
+         */
+        public void supprimerBaseDeDonnees(String motcle) {
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=DELETE";
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                        .getConfig().getServiceBaseUrl()
+                                        + "/InventoryKeyWordList/"
+                                        + iModele.getIdentifiant()
+                                        + "/"
+                                        + motcle);
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                if (response.equals("ERROR")) {
+                                                        Window
+                                                                        .alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application,"
+                                                                                        + "nous vous invitons à recharger la page. ");
+                                                }
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+        /**
+         * Envoie requete au serveur jrest pour modifier un mot clé
+         *
+         * @param motcle
+         *            le mots clés à modifier avec son parent et son identifiant
+         */
+        public void modifierBaseDeDonnees(String motcle) {
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=modification" + motcle;
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                        .getConfig().getServiceBaseUrl()
+                                        + "/InventoryKeyWordList/" + iModele.getIdentifiant());
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+        /**
+         * Envoie requete au serveur jrest pour modifier un mot clé
+         *
+         * @param motcle
+         *            le mots clés à ajouter avec son ancien parent, son nouveau et
+         *            son identifiant
+         */
+        public void deplacerBaseDeDonnees(String motcle) {
+                if (!motcle.equals("")) {
+                        String postData = "";
+                        postData += "&action=deplacement" + motcle;
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                        .getConfig().getServiceBaseUrl()
+                                        + "/InventoryKeyWordList/" + iModele.getIdentifiant());
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                });
+                        } catch (RequestException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/LienImageAsynchroneDAO.java
 New file
 ,0 → 1,99
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.image.ImageModele;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+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.user.client.Window;
+public class LienImageAsynchroneDAO {
+        private ImageModele iModele = null ;
+        public LienImageAsynchroneDAO(ImageModele im) {
+                iModele = im;
+        }
+        /**
+         * 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 = "&coi_ce_image="+id ;
+                // et on envoie ça au serveur
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImageLink/" + iModele.getIdentifiant() + "/" + paramGet);
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                public void onResponseReceived(Request request,
+                                                Response response) {
+                                        Window.alert(response.toString()) ;
+                                }
+                        });
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+        public void lierImageBaseDeDonnees(String idsImages, String idsObs) {
+                String postData = "";
+                postData += "&coi_ce_image="+idsImages ;
+                postData += "&coi_ce_observation="+idsObs ;
+                postData += "&identifiant="+iModele.getIdentifiant() ;
+                Window.alert("data postée : "+postData) ;
+                // et on envoie ça au serveur
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
+                                .getConfig().getServiceBaseUrl()
+                                + "/inventoryImageLink/");
+                try {
+                        rb.sendRequest(postData, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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/ObservationAsynchroneDAO.java
 New file
 ,0 → 1,88
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationModele;
+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.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+import com.google.gwt.user.client.Window;
+/**
+ * DAO d'accès a une observation
+ *
+ * @author aurelien
+ *
+ */
+public class ObservationAsynchroneDAO {
+        /**
+         * Le modele associé au DAO
+         */
+        private ObservationModele oModele = null;
+        public ObservationAsynchroneDAO(ObservationModele obs) {
+                oModele = obs;
+        }
+        /**
+         * Setteur pour le modèle
+         *
+         * @param obs
+         *            le modèle à associer
+         */
+        public void setoModele(ObservationModele obs) {
+                oModele = obs;
+        }
+        /**
+         * Envoie requete au serveur pour ajouter une observations
+         *
+         * @param motcle
+         *            le mots clés à ajouter avec son parent et son identifiant
+         */
+        public void ajouter(final Rafraichissable r, String utilisateur, final Observation obs) {
+//              private void addElement(String nom_sel, String num_nom_sel, String nom_ret,
+        //                      String num_nom_ret, String num_taxon, String famille,final String loc, String id_location,String dat, String lieu, String sta,  String mil, String comment) {
+                        RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,oModele.getConfig().getServiceBaseUrl()+ "/Inventory/") ;
+                        String postData = "identifiant="
+                                + utilisateur + "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi()) + "&num_nom_sel=" + obs.getNumeroNomenclaturalSaisi()
+                                + "&nom_ret=" + URL.encodeComponent(obs.getNomRetenu()) + "&num_nom_ret=" + obs.getNumeroNomenclaturalRetenu()
+                                + "&num_taxon=" + obs.getNumeroTaxonomique() + "&famille=" + URL.encodeComponent(obs.getFamille()) + "&location=" + URL.encodeComponent(obs.getLocalite()) + "&id_location=" + obs.getIdentifiantLocalite() + "&date_observation=" +  obs.getDate()
+                                + "&lieudit="+ URL.encodeComponent(obs.getLieudit()) + "&station="+ URL.encodeComponent(obs.getLieudit()) +"&milieu="+ URL.encodeComponent(obs.getMilieu()) + "&commentaire="+ URL.encodeComponent(obs.getCommentaire()) ;
+                        try {
+                                rb.sendRequest(postData, new RequestCallback() {
+                                        public void onError(Request request, Throwable exception) {
+                                                // TODO Auto-generated method stub
+                                        }
+                                        public void onResponseReceived(Request request,
+                                                        Response response) {
+                                                r.rafraichir(obs,true);
+                                        }
+                                }) ;
+                        } catch (RequestException e) {
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeObservationAsynchroneDAO.java
 New file
 ,0 → 1,143
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.Util;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationModele;
+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.json.client.JSONArray;
+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.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+/**
+ * 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 ;
+        public ListeObservationAsynchroneDAO(ObservationModele observationModele)
+        {
+                this.observationModele=observationModele;
+        }
+        /**
+         * 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 void obtenirListeObservation(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...)
+                        // ils contiennent limite et taille page
+                        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
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,observationModele.getConfig().getServiceBaseUrl()
+                                +"/InventoryObservationList/"+utilisateur+"/"+requete) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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) {
+                                                JSONArray observation;
+                                                final int taillemax = reponse.size();
+                                                observationData = new ListeObservation(taillemax);
+                                                for (int i = 0; i < taillemax; i++) {
+                                                        if ((observation=reponse.get(i).isArray()) != null) {
+                                                                String transmis=((JSONString) observation.get(13)).stringValue();
+                                                                String identifiantLocalite=((JSONString) observation.get(14)).toString();
+                                                                String nomSaisi=Util.toCelString(((JSONString) observation.get(0)).toString());
+                                                                String nomRetenu=Util.toCelString(((JSONString) observation.get(2)).toString());
+                                                                String numeroNomenclaturalSaisi=((JSONString) observation.get(1)).stringValue();
+                                                                String numeroNomenclaturalRetenu=((JSONString) observation.get(3)).stringValue();
+                                                                String numeroTaxonomique=((JSONString) observation.get(4)).stringValue();
+                                                                String famille=Util.toCelString(((JSONString) observation .get(5)).toString());
+                                                                String localite=Util.toCelString(((JSONString) observation .get(6)).toString());
+                                                                String lieudit=Util.toCelString(((JSONString) observation .get(9)).toString());
+                                                                String station=Util.toCelString(((JSONString) observation .get(10)).toString());
+                                                                String milieu=Util.toCelString(((JSONString) observation .get(11)).toString());
+                                                                String commentaire=Util.toCelString(((JSONString) observation .get(12)).toString());
+                                                                String date=((JSONString) observation .get(8)).stringValue();
+                                                                String numeroOrdre=((JSONString) observation.get(7)).stringValue();
+                                                                Observation obs=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclaturalSaisi, numeroNomenclaturalRetenu ,numeroTaxonomique, famille, localite, identifiantLocalite, lieudit, station, milieu, commentaire, date, numeroOrdre);
+                                                                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
+                                        r.rafraichir(observationData,true);
+                                }
+                        }) ;
+                } catch (RequestException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/Utilisateur.java
 New file
 ,0 → 1,33
+package org.tela_botanica.client.modeles;
+public class Utilisateur {
+        private String identifiant=null;
+        private boolean identifie=false;
+        public Utilisateur(String identifiant, boolean identifie) {
+                this.identifiant=identifiant;
+                this.identifie=identifie;
+        }
+        /**
+         * Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session
+         * @return String identifiant
+         */
+        public String getIdentifiant() {
+                return identifiant;
+        }
+        /**
+         * Retourne vrai si utilisateur identifie
+         * @return boolean
+         */
+        public boolean isIdentifie() {
+                return identifie;
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/NombreObservationAsynchroneDAO.java
 New file
 ,0 → 1,106
+package org.tela_botanica.client.modeles;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationModele;
+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.json.client.JSONParser;
+import com.google.gwt.json.client.JSONString;
+import com.google.gwt.json.client.JSONValue;
+import com.google.gwt.user.client.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+/**
+ * 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 ;
+        public NombreObservationAsynchroneDAO(ObservationModele observationModele)
+        {
+                this.observationModele=observationModele;
+        }
+        /**
+         * 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].equals(""))
+                                {
+                                        if(i!= 0)
+                                        {
+                                                requete += "&";
+                                        }
+                                        requete += criteres[i][0]+"="+criteres[i][1] ;
+                                }
+                        }
+                }
+                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,observationModele.getConfig().getServiceBaseUrl()+"/InventoryObservationCount/"+utilisateur+"/"+requete) ;
+                try {
+                        rb.sendRequest(null, new RequestCallback() {
+                                public void onError(Request request, Throwable exception) {
+                                        // TODO Auto-generated method stub
+                                }
+                                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.isArray() != null)
+                                        {
+                                                // qui contient une valeur : le nombre d'images correspondant au critères
+                                                JSONValue res = responseValue.isArray().get(0) ;
+                                                        JSONString reponseNombre = res.isString() ;
+                                                        int maxObservations = Integer.parseInt(reponseNombre.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/ReferentielNom.java
 New file
 ,0 → 1,54
+package org.tela_botanica.client.modeles;
+/**
+ *
+ * Classe representant un element du referentiel de nom
+ *
+ */
+public class ReferentielNom {
+        private String nom=null;
+        private String numeroNom=null;
+        public ReferentielNom() {
+        }
+        /**
+         * @param nom
+         * @param numeroNom
+         *
+         */
+        public ReferentielNom(String nom, String numeroNom) {
+                this.nom = nom;
+                this.numeroNom = numeroNom;
+        }
+        public String getNom() {
+                return nom;
+        }
+        public String getNumeroNom() {
+                return numeroNom;
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/modeles/ListeReferentielNom.java
 New file
 ,0 → 1,52
+package org.tela_botanica.client.modeles;
+import java.util.HashMap;
+/**
+ * table de hachage composée de noms, renvoyé par les objets de type DAO
+ * pour les noms
+ * La clé est l'identifiant du nom dans la base de données, et la valeur un objet
+ * de type ReferentielNom
+ * @author david delon
+ *
+ */
+public class ListeReferentielNom extends HashMap<String, ReferentielNom> {
+        private static final long serialVersionUID = 3214510270773281540L;
+        /**
+         * Constructeur sans paramètres
+         */
+        public ListeReferentielNom()
+        {
+                super();
+        }
+        /**
+         * Constructeur avec paramètre
+         * @param taille la taille de la table de hachage
+         */
+        public ListeReferentielNom(int taille)
+        {
+                super(taille);
+        }
+        /**
+         * Constructeur avec paramètre
+         * @param ic un tableau d'ImageCarnet
+         */
+        public ListeReferentielNom(ReferentielNom[] nom)
+        {
+                super() ;
+                for (int i = 0; i < nom.length; i++)
+                {
+                        if(nom[i] != null && nom[i] instanceof ReferentielNom)
+                        {
+                                this.put(nom[i].getNumeroNom(),nom[i]);
+                        }
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ImageCarnet.java
 New file
 ,0 → 1,368
+package org.tela_botanica.client.modeles;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Set;
+import com.google.gwt.json.client.JSONObject;
+/**
+ *
+ * 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 (image.get(key).isString() != null) {
+                                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);
+                        }
+                }
+        }
+        /**
+         * Surcharge de toString qui affiche toutes les propriétés de l'image
+         */
+        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("ci_id_image");
+        }
+        /**
+         * Acesseur pour le numero d'ordre de l'image
+         *
+         * @return l'ordre de l'image
+         */
+        public String getOrdre() {
+                return renvoyerValeurCorrecte("ci_ordre");
+        }
+        /**
+         * Base de l'url serveur pour les images
+         *
+         * @return url racine pour les images
+         */
+        public String getBaseUrl() {
+                return "http://162.38.234.9/Documents/images_serveur/";
+        }
+        /**
+         * 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[] getBaseFileName() {
+                String id = getId();
+                int maxZeros = 9 - id.length();
+                for (int i = 0; i < maxZeros; i++) {
+                        id = "0" + id;
+                }
+                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;
+        }
+        /**
+         * Renvoie le chemin et nom du fichier grand format
+         *
+         * @return le chemin du fichier grand format
+         */
+        public String getLUrl() {
+                String[] infosFichier = getBaseFileName();
+                return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/L/"
+                                + infosFichier[0] + "_L.jpg";
+        }
+        /**
+         * Renvoie le chemin et nom du fichier petit format
+         *
+         * @return le chemin du fichier petit format
+         */
+        public String getSUrl() {
+                String[] infosFichier = getBaseFileName();
+                return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/S/"
+                                + infosFichier[0] + "_S.jpg";
+        }
+        /**
+         * Renvoie le chemin et nom du fichier moyen format
+         *
+         * @return le chemin du fichier moyen format
+         */
+        public String getMUrl() {
+                String[] infosFichier = getBaseFileName();
+                return getBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/M/"
+                                + infosFichier[0] + "_M.jpg";
+        }
+        /**
+         * Renvoie la taille de l'image
+         *
+         * @return un tableau de deux string contenant la hauteur puis la largeur
+         */
+        public String[] getTailleImage() {
+                String[] XY = { renvoyerValeurCorrecte("ci_meta_height"),
+                                renvoyerValeurCorrecte("ci_meta_width") };
+                return XY;
+        }
+        public String[] getNote() {
+                String[] note = { renvoyerValeurCorrecte("ci_note_image") };
+                return note;
+        }
+        /**
+         * Renvoie la date exif associée à l'image
+         *
+         * @return la date associée à l'image
+         */
+        public String getDate() {
+                return renvoyerValeurCorrecte("ci_meta_date");
+        }
+        /**
+         * Renvoie la ville associée à l'image
+         *
+         * @return la ville iptc
+         */
+        public Object getIptcCity() {
+                return renvoyerValeurCorrecte("ci_meta_iptc_city");
+        }
+        /**
+         * Renvoie le fabricant de l'appareil
+         *
+         * @return le fabricant
+         */
+        public String getMake() {
+                return renvoyerValeurCorrecte("ci_meta_make");
+        }
+        /**
+         * Renvoie le modele de l'appareil
+         *
+         * @return le modele
+         */
+        public String getModel() {
+                return renvoyerValeurCorrecte("ci_meta_model");
+        }
+        /**
+         * Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
+         *
+         * @return les métadonnées iptc
+         */
+        public String[][] getMetadonnesIptc() {
+                String[][] metaIptc = new String[14][2];
+                int elem = 0;
+                for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
+                        String key = it.next();
+                        // on filtre le "ci"
+                        String type[] = key.split("_", 3);
+                        // si c'est une metadonnee exif ou iptc
+                        if (type[1].equals("meta")) {
+                                String[] genre = type[2].split("_", 2);
+                                if (genre[0].equals("iptc")) {
+                                        String nom = genre[1];
+                                        metaIptc[elem][0] = nom;
+                                        metaIptc[elem][1] = renvoyerValeurCorrecte(key);
+                                        elem++;
+                                }
+                        }
+                }
+                return metaIptc;
+        }
+        /**
+         * Renvoie un tableau nom / valeur de toutes les metadonnées Exif
+         *
+         * @return les métadonnées Exif
+         */
+        public String[][] getMetadonnesExif() {
+                String[][] metaExif = new String[31][2];
+                int elem = 0;
+                for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
+                        String key = it.next();
+                        // on filtre le "ci"
+                        String type[] = key.split("_", 3);
+                        // si c'est une metadonnee exif ou iptc
+                        if (type[1].equals("meta")) {
+                                String[] genre = type[2].split("_", 2);
+                                if (genre[0].equals("exif")) {
+                                        String nom = genre[1];
+                                        metaExif[elem][0] = nom;
+                                        metaExif[elem][1] = renvoyerValeurCorrecte(key);
+                                        elem++;
+                                }
+                        }
+                }
+                return metaExif;
+        }
+        /**
+         * 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] = "ci_meta_comment";
+                metaGen[0][1] = this.renvoyerValeurCorrecte("ci_meta_comment");
+                metaGen[1][0] = "ci_meta_date";
+                metaGen[1][1] = this.renvoyerValeurCorrecte("ci_meta_date");
+                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("ci_meta_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("ci_meta_comment", commentaires);
+                put("ci_note_image", note);
+                put("ci_meta_date", 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("ci_meta_mots_cles", motsClesEnCours);
+        }
+}

 /trunk/src/org/tela_botanica/client/modeles/ListeImageCarnet.java
 New file
 ,0 → 1,54
+package org.tela_botanica.client.modeles;
+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/observation/ListeObservationsVue.java
 New file
 ,0 → 1,921
+/**
+ David Delon david.delon@clapas.net 2007
+ */
+/*
+ * ListeObservationsVue.java  (Composite de Panel)
+ *
+ * Cas d'utilisation :
+ *
+ * Affichage de releve
+ *
+ * 1 : Recherche du nombre de releves associe au navigateur ou a l'utilisateur est connecte, en fonction des criteres de selection
+ * 2 : Recherche des releves correspondant au critere precedent
+ * 3 : Affichage des releves avec positionnement sur le dernier releve
+ *
+ * Selection de releve
+ *
+ * 1 : L'utilisateur selectionne un releve : lancement de l'affichage detaille pour le releve selectionne
+ *
+ *
+ * Pagination :
+ *
+ * 1 : Avancement ou recul d'une page
+ *
+ *
+ *
+ *  Suppression d'une liste d'element
+ */
+/* Actions declenchees :
+ *
+ * onInventoryItemSelected(numero d'ordre de la ligne selectionne) : selection d'une ligne
+ * onInventoryItemUnselected(numero d'ordre de la ligne selectionne) : deselection d'une ligne
+ * onInventoryUpdated(localite) : action suite a la modification, suppression, creation d'un element d'inventaire
+ *
+ */
+package org.tela_botanica.client.observation;
+import org.tela_botanica.client.modeles.Observation;
+import com.google.gwt.user.client.HTTPRequest;
+import com.google.gwt.user.client.ResponseTextHandler;
+import com.google.gwt.user.client.ui.Composite;
+import com.google.gwt.user.client.ui.DockPanel;
+import com.google.gwt.user.client.ui.HorizontalPanel;
+import com.google.gwt.user.client.ui.Button;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.Widget;
+import com.google.gwt.user.client.ui.ClickListener;
+import com.google.gwt.user.client.ui.HasHorizontalAlignment;
+import com.google.gwt.user.client.ui.HasVerticalAlignment;
+public class ListeObservationsVue extends Composite
+                 {
+        // Debut Barre de navigation
+        private class NavBar extends Composite implements ClickListener {
+                public final DockPanel bar = new DockPanel();
+                public final Button gotoFirst = new Button("&lt;&lt;", this);
+                public final Button gotoNext = new Button("&gt;", this);
+                public final Button gotoPrev = new Button("&lt;", this);
+                public final Button gotoEnd = new Button("&gt;&gt;", this);
+                public final Label status = new Label();
+                public NavBar() {
+                        initWidget(bar);
+                        status.setWordWrap(false);
+                        HorizontalPanel buttons = new HorizontalPanel();
+                        buttons.add(status);
+                        buttons.setCellHorizontalAlignment(status, HasHorizontalAlignment.ALIGN_RIGHT);
+                        buttons.setCellVerticalAlignment(status, HasVerticalAlignment.ALIGN_MIDDLE);
+                        buttons.add(gotoFirst);
+                        buttons.add(gotoPrev);
+                        buttons.add(gotoNext);
+                        buttons.add(gotoEnd);
+                        bar.add(buttons, DockPanel.EAST);
+                }
+                public void onClick(Widget sender) {
+                        if (sender == gotoNext) {
+                                // Move forward a page.
+                                startIndex += VISIBLE_TAXON_COUNT;
+                                if (startIndex >= count)
+                                        startIndex -= VISIBLE_TAXON_COUNT;
+                        } else {
+                                if (sender == gotoPrev) {
+                                        // Move back a page.
+                                        startIndex -= VISIBLE_TAXON_COUNT;
+                                        if (startIndex < 0)
+                                                startIndex = 0;
+                                } else {
+                                        if (sender == gotoEnd) {
+                                                gotoEnd();
+                                        } else {
+                                                if (sender == gotoFirst) {
+                                                        startIndex = 0;
+                                                }
+                                        }
+                                }
+                        }
+                        getListeObservation();
+                }
+        }
+        // Fin Barre de navigation
+        // Conteneur (header et table sont dans panel)
+//      private ContentPanel panel =null;
+//      private Table table = null;
+        // Services
+        private String serviceBaseUrl = null;
+        private String user;
+        private ObservationMediateur observationMediateur = null;
+        // Navigation
+        private int startIndex = 0;
+        private int count = 0;
+        private static final int VISIBLE_TAXON_COUNT = 15;
+        private NavBar navBar=null;
+        // Filtre par defaut :
+        private String identifiantLocalite = "all";
+        private String localite = "all";
+        private String annee = "all";
+        private String mois = "all";
+        private String jour = "all";
+        private String rechercheLibre = "all";
+        private String lieudit = "all";
+        private String ordre= null;
+        public ListeObservationsVue(ObservationMediateur observationMediateur) {
+                // Traitement contexte utilisateur et service
+                this.observationMediateur=observationMediateur;
+        //    panel= new ContentPanel(Style.HEADER);
+          //  panel.setLayout(new FillLayout());
+            // Barre navigation integree au header
+                navBar = new NavBar();
+        //      panel.getHeader().addWidget(navBar);
+                //  Contenu :
+                //  Colonnes :
+//              TableColumn[] columns = new TableColumn[6];
+                // TODO : renderer date, alignement etc
+        /*
+                columns[0] = new TableColumn("etat","Transmis", 50);
+                columns[1] = new TableColumn("nom","Nom saisi", 250);
+                columns[2] = new TableColumn("nomr","Nom retenu", 250);
+                columns[3] = new TableColumn("lieu","Lieu", 350);
+                columns[4] = new TableColumn("date","Date", 75);
+                columns[5] = new TableColumn("ordre","Ordre", 50);
+                TableColumnModel cm = new TableColumnModel(columns);
+                // Table :
+                table = new Table(Style.MULTI | Style.HORIZONTAL, cm);
+                table.setBorders(false);
+                panel.add(table);
+                // Selection d'une ligne
+                table.addListener(Events.RowClick, new Listener() {
+                      public void handleEvent(BaseEvent be) {
+                        TableItem item=(TableItem) be.item;
+                        if (item!=null) {
+                                if (ordre==null) { // Affichage de la ligne selectionne
+                                        ordre= (String) item.getValue(5);
+        //                              observationMediateur.onInventoryItemSelected(ordre);
+                                }
+                                else {
+                                        // Si une ligne etait deja selectionne
+                                        if (ordre.compareTo((String) item.getValue(5))==0) { // C'est la meme, on la deselectionne
+                                                ordre=null;
+                                                table.deselect(be.rowIndex);
+                //                              observationMediateur.onInventoryItemUnselected();
+                                        }
+                                        else {
+                                                ordre= (String) item.getValue(5); // C'est une autre, on la selectionne
+//                                              observationMediateur.onInventoryItemSelected(ordre);
+                                        }
+                                }
+                        }
+                      }
+                });
+                */
+        // initWidget(panel);
+        }
+        /**
+         * Suppression d'un ensemble d'element de la liste d'inventaire, on garde ici car s'applique a plusieurs elements
+         *
+         */
+        public void deleteElement() {
+/*
+                setStatusDisabled();
+                TableItem[] selection=table.getSelection();
+                StringBuffer ids=new StringBuffer();
+                for (int i = 0; i < selection.length; i++) {
+                        ids.append((String)(((TableItem) selection[i]).getValue(5)));
+                        if (i<(selection.length-1)) ids.append(",");
+                }
+                if (ids.length()>0) {
+                        HTTPRequest.asyncPost(serviceBaseUrl + "/Inventory/" + user
+                                                        + "/" + ids.toString(), "action=DELETE",
+                                                        new ResponseTextHandler() {
+                                                                public void onCompletion(String str) {
+        //                                                                              observationMediateur.onInventoryUpdated(identifiantLocalite,"all","all");
+                //                                                                      observationMediateur.getEntryView().clear();
+                                                                }
+                                                        });
+                }
+                setStatusEnabled();
+*/
+        }
+        /**
+         * Transmission de releve a Tela, on garde ici car s'applique a plusieurs elements
+         */
+        public void transmitElement() {
+                setStatusDisabled();
+/*              TableItem[] selection=table.getSelection();
+                StringBuffer ids=new StringBuffer();
+                for (int i = 0; i < selection.length; i++) {
+                        ids.append((String)(((TableItem) selection[i]).getValue(5)));
+                        if (i<(selection.length-1)) ids.append(",");
+                }
+                if (ids.length()>0) {
+                        HTTPRequest.asyncPost(serviceBaseUrl + "/InventoryTransmit/" + user
+                                                        + "/" + ids.toString(), "transmission=1",
+                                                        new ResponseTextHandler() {
+                                                                public void onCompletion(String str) {
+                                                                                        getListeObservation(); // Pour affichage logo
+                                                                }
+                                                        });
+                }
+                setStatusEnabled();
+                */
+        }
+        /**
+         * Recherche nombre d'enregistrement pour l'utilisateur et la localite en cours
+         *
+         */
+        public void initialiser() {
+                setStatusDisabled();
+        //      observationMediateur.addListener(ObservationMediateur.NOMBRE_OBSERVATION,this);
+        //      observationMediateur.getNombreObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre); // Retour dans handlevent() NOMBRE_OBSERVATION
+        }
+        /**
+         * Mise a jour de l'affichage, a partir des donnaes d'inventaire deja
+         * saisies. La valeur de this.startIndex permet de determiner quelles
+         * donnaes seront affichees
+         *
+         */
+        public void getListeObservation() {
+        //      observationMediateur.addListener(ObservationMediateur.LISTE_OBSERVATION,this);
+        //      observationMediateur.getListeObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre, startIndex, VISIBLE_TAXON_COUNT); // Retour dans handlevent() LISTE_OBSERVATION
+        }
+        public void afficherListeObservation() {
+//              Observation[] listeObservation =observationMediateur.getObservation().getListeObservation();
+                /*
+                for (int i=0;i<listeObservation.length;i++) {
+                        Object[] values = new Object[6];
+                        values[0]="0";
+                        values[2]="2";
+                        values[3]="3";
+                        values[4]="4";
+                        values[5]="5";
+                        values[1]=listeObservation[i].getNomSaisi();
+                        */
+        //      table.add(new TableItem(values));
+                }
+//      Ligne d'information
+                // Toutes date par defaut
+/*
+                HTTPRequest.asyncGet(serviceBaseUrl + "/InventoryItemList/" + user + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) +"/" + annee  + "/"  + mois  + "/"  + jour   + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit) + "/"
+                                + startIndex + "/" + VISIBLE_TAXON_COUNT,
+                new ResponseTextHandler() {
+                        public void onCompletion(String str) {
+                                JSONValue jsonValue = JSONParser.parse(str);
+                                JSONArray jsonArray;
+                                JSONArray jsonArrayNested;
+                                int i=0;
+                                if ((jsonArray = jsonValue.isArray()) != null) {
+                                        StringBuffer lieu=null;
+                                        int arraySize = jsonArray.size();
+                                        for (i = 0; i < arraySize; ++i) {
+                                                if ((jsonArrayNested = jsonArray.get(i).isArray()) != null) {
+                                                        Object[] values = new Object[6];
+                                                        // Statut Observation transmise ?
+                                                        String atransmit=((JSONString) jsonArrayNested .get(13)).stringValue();
+                                                        if (atransmit.compareTo("1")==0) {
+                                                                values[0] = new Image("tela.gif");
+                                                        }
+                                                        else {
+                                                                values[0] = new HTML("&nbsp;");
+                                                        }
+                                                        // Nom saisi
+                                                        values[1] = new HTML("<b>"+Util.toCelString(((JSONString) jsonArrayNested .get(0)).toString())+"</b>");
+                                                        // Nom retenu
+                                                        String aname=Util.toCelString(((JSONString) jsonArrayNested .get(2)).toString());
+                                                        if (aname.compareTo("null")==0) {
+                                                                values[2] = new HTML("&nbsp;");
+                                                        }
+                                                        else {
+                                                                values[2] = new HTML(aname);
+                                                        }
+                                                        /*
+                                                         /*
+                                                        // Num nomenclatural
+                                                        String ann=((JSONString) jsonArrayNested .get(3)).stringValue();
+                                                        if (ann.compareTo("0")!=0) {
+                                                                observationText.append(""+ann+"-");
+                                                        }
+                                                        else {
+                                                                observationText.append("0-");
+                                                        }
+                                                        // Num Taxonomique
+                                                        String ant=((JSONString) jsonArrayNested .get(4)).stringValue();
+                                                        if (ant.compareTo("0")!=0) {
+                                                                observationText.append(ant+", ");
+                                                        }
+                                                        else {
+                                                                observationText.append("0, ");
+                                                        }
+                                                        // Famille
+                                                        String afamily=Util.toCelString(((JSONString) jsonArrayNested .get(5)).toString());
+                                                        if (afamily.compareTo("null")==0) {
+                                                                //
+                                                        }
+                                                        else {
+                                                                observationText.append(afamily+", ");
+                                                        }
+                                                        */
+                /*
+//                                                      Localisation - Lieu
+                                                        lieu=new StringBuffer();
+                                                        String aloc=Util.toCelString(((JSONString) jsonArrayNested .get(6)).toString());
+                                                                if (aloc.compareTo("000null")==0) {
+                                                                        if (lieu.length()==0) {
+                                                                                lieu.append("Commune absente");
+                                                                        }
+                                                                        else {
+                                                                                lieu.append("commune absente");
+                                                                        }
+                                                                }
+                                                                else {
+                                                                        if (lieu.length()==0) {
+                                                                                lieu.append("Commune de "+aloc);
+                                                                        }
+                                                                        else {
+                                                                                lieu.append("commune de "+aloc);
+                                                                        }
+                                                                }
+                                                                String alieudit=Util.toCelString(((JSONString) jsonArrayNested .get(9)).toString());
+//                                                              Localisation - Lieu dit
+                                                                if (alieudit.compareTo("000null")!=0) {
+                                                                        lieu.append(", "+alieudit);
+                                                                }
+//                                                              Station -
+                                                                String astation=Util.toCelString(((JSONString) jsonArrayNested .get(10)).toString());
+                                                                if (astation.compareTo("000null")!=0) {
+                                                                        lieu.append(", "+astation);
+                                                                }
+//                                                              Milieu
+                                                                String amilieu=Util.toCelString(((JSONString) jsonArrayNested .get(11)).toString());
+                                                                if (amilieu.compareTo("000null")!=0) {
+                                                                        lieu.append(", "+amilieu);
+                                                                }
+                                                                String acomment=Util.toCelString(((JSONString) jsonArrayNested .get(12)).toString());
+//                                                              Commentaire
+                                                                if (acomment.compareTo("null")!=0) {
+                                                                        lieu.append(", "+acomment);
+                                                                }
+                                                                if (lieu.toString().compareTo("")==0) {
+                                                                        values[3] = new HTML("&nbsp;");
+                                                                }
+                                                                else {
+                                                                        values[3] = new HTML(lieu.toString());
+                                                                }
+                                                                String adate=((JSONString) jsonArrayNested .get(8)).stringValue();
+//                                                              Date
+                                                                if (adate.compareTo("0000-00-00 00:00:00")!=0) {
+                                                                        values[4]=new HTML("<b>"+adate+"</b>");
+                                                                }
+                                                                else {
+                                                                        values[4] = new HTML("&nbsp;");
+                                                                }
+                                                        String aordre=((JSONString) jsonArrayNested.get(7)).stringValue();
+                                                        // Numero d'ordre (cache)
+                                                        values[5] = aordre;
+                                                if (i>=table.getItemCount()) {
+                                                        TableItem item = new TableItem(values);
+                                                        table.add(item);
+                                                        }
+                                                        else {
+                                                                TableItem item=table.getItem(i);
+                                                                item.setValue(0,values[0]);
+                                                                item.setValue(1,values[1]);
+                                                                item.setValue(2,values[2]);
+                                                                item.setValue(3,values[3]);
+                                                                item.setValue(4,values[4]);
+                                                                item.setValue(5,values[5]);
+                                                        }
+                                                // Spagetti
+                                                        if (ordre!=null) {
+                                                                if (aordre.compareTo(ordre)==0) {
+                                                                        table.select(i);
+                                                                }
+                                                                else {
+                                                                        table.deselect(i);
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                }
+                                // Suppression fin ancien affichage
+                                if (i<table.getItemCount()) {
+                                         for (int j = table.getItemCount() -1 ; j >= i; j--) {
+                                                 TableItem item=table.getItem(j);
+                                                 table.remove(item);
+                                         }
+                                }
+                                setStatusEnabled();
+                        }
+                });
+                                */
+//      }
+        /**
+         * Affichage message d'attente et desactivation navigation
+         *
+         * @param
+         * @return void
+         */
+        private void setStatusDisabled() {
+                navBar.gotoFirst.setEnabled(false);
+                navBar.gotoPrev.setEnabled(false);
+                navBar.gotoNext.setEnabled(false);
+                navBar.gotoEnd.setEnabled(false);
+                navBar.status.setText("Patientez ...");
+        }
+        /**
+         * Affichage numero de page et gestion de la navigation
+         *
+         */
+        private void setStatusEnabled() {
+                // Il y a forcemment un disabled avant d'arriver ici
+                if (count > 0) {
+                        if (startIndex >= VISIBLE_TAXON_COUNT) { // Au dela de la
+                                                                                                                // premiere page
+                                navBar.gotoPrev.setEnabled(true);
+                                navBar.gotoFirst.setEnabled(true);
+                                if (startIndex < (count - VISIBLE_TAXON_COUNT)) { // Pas la
+                                                                                                                                        // derniere
+                                                                                                                                        // page
+                                        navBar.gotoNext.setEnabled(true);
+                                        navBar.gotoEnd.setEnabled(true);
+                                        navBar.status.setText((startIndex + 1) + " - "
+                                                        + (startIndex + VISIBLE_TAXON_COUNT) + " sur " + count );
+                                } else { // Derniere page
+                                        navBar.status.setText((startIndex + 1) + " - " + count + " sur " + count );
+                                }
+                        } else { // Premiere page
+                                if (count > VISIBLE_TAXON_COUNT) { // Des pages derrieres
+                                        navBar.gotoNext.setEnabled(true);
+                                        navBar.gotoEnd.setEnabled(true);
+                                        navBar.status.setText((startIndex + 1) + " - "
+                                                        + (startIndex + VISIBLE_TAXON_COUNT) + " sur " + count);
+                                } else {
+                                        navBar.status.setText((startIndex + 1) + " - " + count + " sur " + count);
+                                }
+                        }
+                }
+                else { // Pas d'inventaire, pas de navigation
+                        navBar.status.setText("0 - 0 sur 0");
+                }
+        }
+        /*
+         * Positionnement index de parcours (this.startIndex) pour affichage de la
+         * derniere page
+         *
+         * @param
+         * @return void
+         */
+        private void gotoEnd() {
+                if ((count == 0) || (count % VISIBLE_TAXON_COUNT) > 0) {
+                        startIndex = count - (count % VISIBLE_TAXON_COUNT);
+                } else {
+                        startIndex = count - VISIBLE_TAXON_COUNT;
+                }
+        }
+        /*
+         * Recherche en cours
+         *
+         */
+        public void setRechercheLibre(String search) {
+                this.rechercheLibre = search;
+        }
+        /*
+         * Departement en cours
+         *
+         */
+        public void setIdLocation(String id_location) {
+                this.identifiantLocalite = id_location;
+        }
+        /*
+         * Localite en cours
+         *
+         */
+        public void setLocalite(String location) {
+                this.localite = location;
+        }
+        /*
+         * Lieudit en cours
+         *
+         */
+        public void setLieudit(String lieudit) {
+                this.lieudit = lieudit;
+        }
+        /*
+         * Date en cours
+         *
+         */
+        public void setAnnee(String year) {
+                this.annee = year;
+        }
+        public void setMois(String month) {
+                this.mois = month;
+        }
+        public void setJour(String day) {
+                this.jour = day;
+        }
+        /*
+         * Utilisateur en cours
+         *
+         */
+        public void setUser(String user) {
+                this.user = user;
+        }
+        public void displayFilter() {
+        // Mise a jour boutton export feuille de calcul
+                /*
+        observationMediateur.getActionView().getExportButton().setHTML("<a href=\""+observationMediateur.getServiceBaseUrl()+"/InventoryExport/"
+                        +  user + "/"
+                        + URL.encodeComponent(identifiantLocalite) + "/"
+                        + URL.encodeComponent(localite) + "/"
+                        + URL.encodeComponent(lieudit)+ "/"
+                        + annee + "/"
+                        + mois  + "/"
+                        + jour
+                        + "\">"+"Export&nbsp;tableur</a>");
+        */
+        // Mise a jour ligne de selection
+        String dep;
+        if (identifiantLocalite.compareTo("all")==0) {
+                dep="Tous d&eacute;partements";
+        }
+        else {
+                if (identifiantLocalite.compareTo("000null")==0) {
+                        dep="D&eacute;partements non renseign&eacute;es ";
+                }
+                else {
+                dep="Département "+identifiantLocalite;
+                }
+        }
+        String com;
+        if (localite.compareTo("all")==0) {
+                com=", toutes communes";
+        }
+        else {
+                if (localite.compareTo("000null")==0) {
+                        com=", communes non renseign&eacute;es";
+                }
+                else {
+                com=", commune de "+localite;
+                }
+        }
+        String lieu;
+        if (lieudit.compareTo("all")==0) {
+                lieu=", tous lieux dits";
+        }
+        else {
+                if (lieudit.compareTo("000null")==0) {
+                        lieu=", lieu-dit non renseign&eacute;es";
+                }
+                else {
+                        lieu=", lieu-dit "+ lieudit;
+                }
+        }
+        String dat;
+        if ((annee.compareTo("all")==0) && (mois.compareTo("all")==0) && (jour.compareTo("all")==0)) {
+                dat=", toutes periodes";
+        }
+        else {
+        String yea="";
+        String da="";
+        String mont="";
+        if (annee.compareTo("all")==0) {
+                yea=", toutes ann&eacute;es";
+        }
+        else {
+                if (annee.compareTo("0")==0) {
+                        yea=", periode non renseign&eacute;e";
+                }
+                else {
+                        yea=", "+ annee;
+                if (mois.compareTo("all")==0) {
+                        mont=", tous mois";
+                }
+                else {
+                                mont="/"+ mois;
+                }
+                if (jour.compareTo("all")==0) {
+                        da=", tous jours";
+                }
+                else {
+                                da="/"+ jour;
+                }
+                }
+        }
+        dat=yea + mont + da;
+        }
+        //panel.getHeader().setText(dep + com + lieu + dat);
+}
+        /// EVENEMENTS
+/**
+ * Evenements
+ *
+ */
+        /*
+        public void handleEvent(BaseEvent be) {
+                switch (be.type) {
+                        case ObservationMediateur.NOMBRE_OBSERVATION:
+                                gotoEnd();
+                                getListeObservation();
+                                break;
+                        case ObservationMediateur.LISTE_OBSERVATION:
+                                afficherListeObservation();
+                                break;
+                }
+        }
+*/
+}
+/* +--Fin du code ---------------------------------------------------------------------------------------+
+* $Log$
+* Revision 1.4  2008-11-13 11:27:05  ddelon
+* Reecriture gwt-ext
+*
+* Revision 1.3  2008-06-17 14:16:16  aperonnet
+* *** empty log message ***
+*
+* Revision 1.2  2008-06-09 16:29:01  ddelon
+* import branche observation
+*
+* Revision 1.1  2008-06-09 14:19:37  ddelon
+* Initialisation observation
+*
+* Revision 1.3  2008-04-28 13:10:43  ddelon
+* Integration MyGwt
+*
+* Revision 1.2  2008-01-30 08:55:40  ddelon
+* fin mise en place mygwt
+*
+* Revision 1.1  2008-01-02 21:26:04  ddelon
+* mise en place mygwt
+*
+* Revision 1.8  2007-12-22 14:48:53  ddelon
+* Documentation et refactorisation
+*
+* Revision 1.7  2007-09-17 19:25:34  ddelon
+* Documentation
+*
+*/

 /trunk/src/org/tela_botanica/client/observation/ObservationModele.java
 New file
 ,0 → 1,167
+package org.tela_botanica.client.observation;
+import org.tela_botanica.client.interfaces.FournisseurListe;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.Configuration;
+import org.tela_botanica.client.modeles.ListeObservationAsynchroneDAO;
+import org.tela_botanica.client.modeles.ListeReferentielCommuneAsynchroneDAO;
+import org.tela_botanica.client.modeles.ListeReferentielNom;
+import org.tela_botanica.client.modeles.ListeReferentielNomAsynchroneDAO;
+import org.tela_botanica.client.modeles.NombreObservationAsynchroneDAO;
+import org.tela_botanica.client.modeles.ObservationAsynchroneDAO;
+public class ObservationModele  {
+        /**
+         * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
+         */
+        private static boolean estInstancie = false ;
+        /**
+         * La configuration en cours
+         */
+        private Configuration config = null;
+        /**
+         * Le médiateur associé au modèle
+         */
+        private ObservationMediateur observationMediateur = null ;
+        /**
+         * Retourne une instance de manière unique
+         * @param im le médiateur à associer
+         * @return l'instance du modèle
+         */
+        static ObservationModele Instance(ObservationMediateur observationMediateur)
+        {
+                // si le modèle n'est pas encore instancié
+                if(!estInstancie)
+                {
+                        // on en crée un nouveau
+                        estInstancie = true ;
+                        return new ObservationModele(observationMediateur);
+                }
+                else
+                {
+                        // sinon on renvoit null, interdisant explicitement la création d'un autre exemplaire
+                        return null ;
+                }
+        }
+        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 taillePage
+         */
+        public void obtenirNombreObservation(Rafraichissable r) {
+                        String motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ;
+                        // on rassemble les critères
+                        String[][] criteres = {{motsClesFiltres[0][0], motsClesFiltres[0][1]} } ;
+                        // 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, observationMediateur.getIdentifiant(), criteres) ;
+        }
+        /**
+         * 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 motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ;
+                        // ensuite on demande la page correspondante avec les mêmes critères
+                        String[][] criteres2 = { {"limite" ,""+taillePage },{"numero_page",""+pageEncours}, {motsClesFiltres[0][0], motsClesFiltres[0][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, observationMediateur.getIdentifiant(), criteres2);
+        }
+        public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
+                ListeReferentielCommuneAsynchroneDAO refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
+                refDAO.obtenirListeDonnees(r, critere);
+        }
+        public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
+                ListeReferentielNomAsynchroneDAO nomDAO=new ListeReferentielNomAsynchroneDAO(this);
+                nomDAO.obtenirListeDonnees(r, critere);
+        }
+        /**
+         *
+         * Lance la creation d'une observation
+         * @param r : la vue demandeuse de donnee
+         * @param critere : les criteres de selection
+         */
+        public void ajouterObservation(Rafraichissable r) {
+                ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
+        //      obsDAO.ajouter();
+        }
+        /**
+         * Accesseur pour la configuration en cours d'utilisation
+         *
+         * @return la configuration
+         */
+        public Configuration getConfig() {
+                return config;
+        }
+}

 /trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java
 New file
 ,0 → 1,497
+package org.tela_botanica.client.observation;
+import java.util.Iterator;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.interfaces.FournisseurListe;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.ListeObservation;
+import org.tela_botanica.client.modeles.Observation;
+import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
+import org.tela_botanica.client.vues.ListeObservationVue;
+import com.gwtext.client.data.ArrayReader;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.MemoryProxy;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.TabPanel;
+/**
+ * Mediateur gérant les interactions entre vues et les echanges de données
+ * C'est un singleton.
+ * @author aurelien
+ *
+ */
+public class ObservationMediateur implements Rafraichissable {
+        /**
+         * 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("Observation");
+        /**
+         * panneau a onglet pour la liste
+         */
+        private TabPanel ongletsObservation = null ;
+        /**
+         * conteneur du panneau a onglets
+         */
+        private Panel panneauMenuEtOngletsObservation = null ;
+        /**
+         * liste détaillée des Observations
+         */
+        private ListeObservationVue listeObservation = null ;
+        /**
+         * Saisie des Observations
+         */
+        private FormulaireSaisieObservationVue formulaireSaisieObservationVue=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 ;
+        /**
+         * 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 ;
+        /**
+         * Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
+         */
+        private Store st = null ;
+        /**
+         * La liste des observations affichées en cours (verifier utilité)
+         */
+        private ListeObservation cacheObservation = new ListeObservation(0) ;
+        /**
+        /**
+         * constructeur privé (on accède a la classe par la méthode getInstance
+         */
+        private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
+        {
+                this.carnetEnLigneMediateur=carnetEnLigneMediateur;
+                // Demande d'identification
+//              afficherMenuId() ;
+                // on crée un modèle
+                observationModele = ObservationModele.Instance(this);
+                // on gère la mise en page du panneau principal
+                //panneauPrincipalObservation.setLayout(new BorderLayout());
+                // on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
+        //      panneauMenuEtOngletsObservation = new Panel("gg") ;
+        //      panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
+                // le panneau à onglet qui contient la vue
+                //ongletsObservation = new TabPanel();
+                // la liste des observations
+                //Panel panneauListeObservation = new Panel("Liste");
+                listeObservation = new ListeObservationVue(this);
+                // Le formulaire de saisie / modification d'observation
+                formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
+                //panneauListeObservation.setLayout(new FitLayout());
+                //panneauListeObservation.setSize(600,600);
+                //panneauListeObservation.add(listeObservation);
+                // on ajoute les panneaux au panneau à onglets
+                //ongletsObservation.add(panneauListeObservation);
+                // les onglets au centre
+//              panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
+                // on ajoute le panneau qui contient le menu et les onglets d'images au centre
+                //panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
+                panneauPrincipalObservation.add(formulaireSaisieObservationVue);
+                panneauPrincipalObservation.add(listeObservation);
+        }
+        /**
+         * 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 ;
+        }
+        /**
+         * envoie au modèle une demande de mise a jour
+         */
+        public void obtenirNombreObservation() {
+                        listeObservation.masquerChargement();
+                    observationModele.obtenirNombreObservation(this) ;
+        }
+        /**
+         * envoie au modèle une demande de mise a jour
+         */
+        public void obtenirListeObservation() {
+                        observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
+        }
+        /**
+         * 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 = { {"location","Saint-Martin-de-Londres"} } ;
+                return valeursFiltres ;
+        }
+        public String getIdentifiant() {
+                return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
+        }
+        public Panel getPanneauPrincipalObservation() {
+                return panneauPrincipalObservation;
+        }
+        // FIXME TODO : plutot dans la listevu non ?
+        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()][8];
+                                int i = 0 ;
+                                if(data.size() == 0)
+                                {
+                                        pageEncours = 0 ;
+                                }
+                                // on la parse et on récupère les informations quiç nous interessent
+                                for (Iterator it = data.keySet().iterator(); it.hasNext();)
+                                {
+                                        Observation obs=(Observation) data.get(it.next());
+                                        observationData[i][0]= obs.getTransmis();
+                                        observationData[i][1]= obs.getNomSaisi();
+                                        observationData[i][2]= obs.getNomRetenu();
+                                        observationData[i][3]= obs.getLieudit();
+                                        observationData[i][4]= obs.getDate();
+                                        observationData[i][5]= obs.getNumeroOrdre();
+                                        i++ ;
+                                }
+                                // creation du store qui les contient
+                                FieldDef defEtatObservation = new StringFieldDef("etat_observation");
+                                FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
+                                FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
+                                FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
+                                FieldDef defDateObservation = new StringFieldDef("date_observation");
+                                FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
+                                // on associe le store
+                                FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
+                                                defLieuObservation, defDateObservation, defOrdreObservation };
+                                RecordDef rd = new RecordDef(defTab);
+                                final MemoryProxy dataProxy = new MemoryProxy(observationData);
+                                final ArrayReader reader = new ArrayReader(rd);
+                                final Store observationStore = new Store(dataProxy, reader);
+                                st = observationStore ;
+                                st.load() ;
+                                // par défaut le store est trié sur l'ordre d'observations
+                                st.sort("ordre_observation") ;
+                                // si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
+                                if(repandreRafraichissement)
+                                {
+                                        listeObservation.rafraichir(st, false) ;
+                                }
+                }
+                // 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]) ;
+                        obtenirListeObservation();
+                }
+        }
+        /**
+         * 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} ;
+                listeObservation.getToolBarVue().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()) ;
+        }
+        /**
+         * Appelle le modèle pour lui demander les données d'une page à afficher
+         * @param pageCourante le numéro de page à affciher
+         */
+        public void changerNumeroPage(int pageCourante) {
+                pageEncours = pageCourante ;
+                // On lance le chargerment des observations
+                obtenirNombreObservation();
+                listeObservation.getToolBarVue().changerPageCourante(pageCourante);
+        }
+        /**
+         * Appelle le modèle pour qu'il change la taille de page utilisée
+         * @param nouvelleTaillePage la nouvelle taille de page
+         */
+        public void changerTaillePage(int nouvelleTaillePage)
+        {
+                taillePage = nouvelleTaillePage ;
+                pageEncours = calculerPageCourante(nbElements) ;
+                //      On lance le chargerment des observations
+                obtenirNombreObservation();
+                // et on met à jour la taille de page dans les barres d'outils
+                listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
+        }
+        /**
+         *
+         * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
+         * @param r : la vue demandeuse de donnee
+         * @param critere : les criteres de selection
+         */
+        public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
+                observationModele.obtenirListeReferentielCommune(r,critere) ;
+        }
+        /**
+         *
+         * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
+         * @param r : la vue demandeuse de donnee
+         * @param critere : les criteres de selection
+         */
+        public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
+                observationModele.obtenirListeReferentielNom(r,critere) ;
+        }
+        /**
+         *
+         * Lance la creation d'une observation
+         * @param r : la vue demandeuse de donnee
+         * @param critere : les criteres de selection
+         */
+        public void ajouterObservation(Rafraichissable r) {
+                observationModele.ajouterObservation(r) ;
+        }
+}

 /trunk/src/org/tela_botanica/client/Util.java
 New file
 ,0 → 1,12
+package org.tela_botanica.client;
+public class Util {
+        public Util() {
+        }
+        public static String toCelString(String str) {
+                return str.substring(1, str.length() - 1);
+                //
+        }
+}

 /trunk/src/org/tela_botanica/client/CarnetEnLigneMediateur.java
 New file
 ,0 → 1,303
+package org.tela_botanica.client;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.Utilisateur;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import org.tela_botanica.client.vues.EtatConnexionVue;
+import org.tela_botanica.client.vues.FormulaireDeConnexionVue;
+import com.google.gwt.user.client.Timer;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.ui.TabPanel;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.layout.FitLayout;
+import com.gwtext.client.widgets.layout.VerticalLayout;
+/**
+ * Mediateur gérant les interactions entre vues et les echanges de données
+ * C'est un singleton.
+ * @author david delon
+ *
+ */
+public class CarnetEnLigneMediateur implements Rafraichissable {
+        /**
+         * booleen qui verifie l'unicite de l'instance
+         */
+        private static boolean estInstancie = false ;
+        /**
+         * pointeur vers le médiateur lui même (pour le pattern singleton)
+         */
+        private static CarnetEnLigneMediateur thisMediateur = null ;
+        /**
+         * modele de données
+         */
+        private  CarnetEnLigneModele carnetEnLigneModele=null;
+        /**
+         * panneau principal de l'application "Carnet en ligne"
+         */
+        private Panel panneauPrincipalCarnetEnLigne= null ;
+        /**
+         * panneau a onglet pour les observation et les images
+         */
+        private com.gwtext.client.widgets.TabPanel ongletsObservationsImages=null;
+        /**
+         * Indicateur d'etat de la connexion utilisateur
+         */
+        private EtatConnexionVue etatConnexionVue=null;
+        /**
+         * Texte d'invite connexion
+         */
+        private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica";
+        /**
+         * Boolean indiquant un essai de connexion
+         */
+        private boolean tentativeConnection=false;
+        /**
+         *  Formulaire de connexion (lazy instantiation)
+         *
+         */
+        private FormulaireDeConnexionVue formulaireDeConnexionVue=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 VerticalLayout());
+//              On crée un modèle d'acces aux donnnes
+                carnetEnLigneModele=CarnetEnLigneModele.Instance();
+                // La vue affichant le statut de la connexion
+                etatConnexionVue=new EtatConnexionVue(this);
+                // Le panneau à onglet qui contient les 2 applications Observation et Images
+                ongletsObservationsImages = new com.gwtext.client.widgets.TabPanel();
+                panneauPrincipalCarnetEnLigne.add(etatConnexionVue);
+                //      on ajoute le panneau a onglet au panneau principal
+                panneauPrincipalCarnetEnLigne.add(ongletsObservationsImages);
+                // On ajoute les applications
+                observationMediateur = ObservationMediateur.Instance(this);
+                imageMediateur= ImageMediateur.Instance(this);
+                panneauPrincipalCarnetEnLigne.setSize(Window.getClientWidth(), Window.getClientHeight() - etatConnexionVue.getHeight()) ;
+                imageMediateur.getPanneauPrincipalImage().setSize(panneauPrincipalCarnetEnLigne.getWidth(),panneauPrincipalCarnetEnLigne.getHeight() - 20) ;
+                observationMediateur.getPanneauPrincipalObservation().setSize(panneauPrincipalCarnetEnLigne.getWidth(),panneauPrincipalCarnetEnLigne.getHeight() - 20) ;
+                //      on ajoute les panneaux  principaux des applications au panneau à onglets
+                ongletsObservationsImages.add(imageMediateur.getPanneauPrincipalImage());
+                ongletsObservationsImages.add(observationMediateur.getPanneauPrincipalObservation());
+        }
+        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() {
+                carnetEnLigneModele.deconnecterUtilisateur(this, utilisateur.getIdentifiant());
+        }
+        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(texteDeconnexion,false);
+                }
+                else {
+                      etatConnexionVue.setEtat(utilisateur.getIdentifiant()+ " (deconnexion)",true);
+                }
+        }
+        /**
+         *
+         * Affichage boite de connexion
+         *
+         */
+        public void afficherDialogueConnexion() {
+                  if (formulaireDeConnexionVue==null) {
+                          formulaireDeConnexionVue= new FormulaireDeConnexionVue(this);
+                  }
+                  // Position it roughly in the middle of the screen.
+                  int left = (Window.getClientWidth() - 512) / 2;
+                  int top = (Window.getClientHeight() - 256) / 2;
+                  formulaireDeConnexionVue.setPopupPosition(left, top);
+                  formulaireDeConnexionVue.show();
+        }
+        public Panel getPanneauPrincipalCarnetEnLigne() {
+                return panneauPrincipalCarnetEnLigne;
+        }
+//       TODO : repandre rafraichissement
+        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
+                        if (nouvelleDonnees instanceof Utilisateur) {
+                                utilisateur = (Utilisateur) nouvelleDonnees;
+                                afficheEtatConnexion();
+                                if ((tentativeConnection) && !utilisateur.isIdentifie()) {
+                                        formulaireDeConnexionVue.afficherMessageAlerte();
+                                }
+                                else {
+                                        if ((tentativeConnection) && utilisateur.isIdentifie()) {
+                                                formulaireDeConnexionVue.hide();
+                                        }
+                                }
+                        // On lance l'affichage des observations
+                                observationMediateur.obtenirNombreObservation();
+                        }
+        }
+}

 /trunk/src/org/tela_botanica/client/image/ImageMediateur.java
 New file
 ,0 → 1,1404
+package org.tela_botanica.client.image;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import org.tela_botanica.client.interfaces.IdVue;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.interfaces.VueListable;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue;
+import org.tela_botanica.client.vues.BarreOutilsVue;
+import org.tela_botanica.client.vues.BarreRechercheFiltreVue;
+import org.tela_botanica.client.vues.GalerieImageVue;
+import org.tela_botanica.client.vues.ListeImageVue;
+import org.tela_botanica.client.vues.MenuImageVue;
+import org.tela_botanica.client.vues.MiniListeObservationVue;
+import org.tela_botanica.client.vues.PanneauFiltresVues;
+import org.tela_botanica.client.vues.PanneauMetadonneesVue;
+import org.tela_botanica.client.vues.ZoomImageVue;
+import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.core.Ext;
+import com.gwtext.client.core.ExtElement;
+import com.gwtext.client.core.RegionPosition;
+import com.gwtext.client.data.Record;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.dd.DragData;
+import com.gwtext.client.dd.DragSource;
+import com.gwtext.client.widgets.BoxComponent;
+import com.gwtext.client.widgets.Component;
+import com.gwtext.client.widgets.Container;
+import com.gwtext.client.widgets.DataView;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.TabPanel;
+import com.gwtext.client.widgets.event.ComponentListenerAdapter;
+import com.gwtext.client.widgets.event.ContainerListener;
+import com.gwtext.client.widgets.event.ContainerListenerAdapter;
+import com.gwtext.client.widgets.event.PanelListener;
+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.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
+ *
+ */
+public class ImageMediateur {
+        /**
+         * 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 PanneauFiltresVues filtres = null;
+        /**
+         * conteneur du panneau a onglets
+         */
+        private Panel panneauMenuEtOngletsImage = null;
+        /**
+         * galerie de miniature
+         */
+        private GalerieImageVue galerieImage = null;
+        /**
+         * liste détaillée des images
+         */
+        private ListeImageVue listeImage = null;
+        /**
+         * vue agrandie de la l'image selectionnée
+         */
+        private ZoomImageVue zoomImage = null;
+        /**
+         * panneau a onglets affichant les métadonnées et les mots clés
+         */
+        private PanneauMetadonneesVue metadonneesIptcExif = null;
+        /**
+         * panneau conteneur pour le panneau a onglet des metadonnées
+         */
+        private final Panel detailsEtMotsCles = new Panel("Détails et mots clés");
+        /**
+         * menu contextuel de manipulation des images
+         */
+        private MenuImageVue menuImageVue = null;
+        /**
+         * barre d'outils
+         */
+        private BarreOutilsVue barreOutilsVue = null;
+        /**
+         * l'indice du dernier onglet sélectionné
+         */
+        private int dernierIndexOnglet = 0;
+        /**
+         * booleen explicitant s'il y a une selection en cours
+         */
+        private boolean selection = false;
+        /**
+         * Filtre pour les mots cles
+         */
+        private ArbreMotsClesFiltreVue filtreMotsCles = null;
+        /**
+         * Filtre pour les commentaires
+         */
+        private BarreRechercheFiltreVue filtreCommentaires = null;
+        /**
+         * 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;
+                initialiser() ;
+        }
+        /**
+         * 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 = new Panel("Images") ;
+                panneauPrincipalImage.setLayout(new BorderLayout()) ;
+                // on crée un modèle
+                iModele = ImageModele.Instance(this);
+                // et on demande l'arbre des mots clés
+                iModele.initialiserArbreMotsCles();
+                // on gère la mise en page du panneau principal
+                // on crée le panneau des filtres
+                filtres = new PanneauFiltresVues(this);
+                filtres.setWidth(200);
+                // le panneau à onglet qui contient les trois vues
+                ongletsImage = new TabPanel();
+                // la galerie
+                galerieImage = new GalerieImageVue(this);
+                // la liste des images
+                Panel panneauListeImage = new Panel("Liste");
+                listeImage = new ListeImageVue(this);
+                panneauListeImage.setLayout(new FitLayout());
+                panneauListeImage.add(listeImage);
+                // le panneau zoom
+                zoomImage = new ZoomImageVue(this);
+                // on ajoute les panneaux au panneau à onglets
+                ongletsImage.add(galerieImage);
+                ongletsImage.add(panneauListeImage);
+                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("25%");
+                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);
+                // on ajoute le panneau qui contient le menu et les onglets d'images au
+                // centre
+                panneauPrincipalImage.add(panneauMenuEtOngletsImage, regionCentre);
+                // et le panneau de métadonnées et d'info sur le coté droit
+                panneauPrincipalImage.add(detailsEtMotsCles, regionEst);
+                // on ajoute les filtres au panneau gauche
+                panneauPrincipalImage.add(filtres,regionOuest) ;
+                // filtres.setCollapsed(false) ;
+                thisMediateur = this ;
+                setIdentifiant(""+"aurelien".hashCode());
+                panneauPrincipalImage.addListener(new ContainerListenerAdapter() {
+                        public void onShow(Component component)
+                        {
+                                changerUtilisateur() ;
+                        }
+                }) ;
+        }
+        /**
+         * Renvoie l'identifiant de l'utilisateur en cours
+         *
+         * @return l'identifiant de l'utilisateur
+         */
+        public String getIdentifiant() {
+                return identifiant;
+        }
+        /**
+         * . 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 l'arbre des filtres
+         *
+         * @return l'arbre pour filtrer les mots clés
+         */
+        public ArbreMotsClesFiltreVue getFiltreMotsCles() {
+                return filtreMotsCles;
+        }
+        /**
+         * 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();
+                        } else {
+                                selection();
+                        }
+                }
+                if (r != getGalerieImage()) {
+                        getGalerieImage().rafraichir(o, false);
+                }
+                if (r != getZoomImage()) {
+                        getZoomImage().rafraichir(o, false);
+                }
+                if (r != getListeImage()) {
+                        getListeImage().rafraichir(o, false);
+                }
+                aucuneSelection();
+                demasquerChargement();
+        }
+        /**
+         * envoie au modèle une demande de mise a jour
+         *
+         * @param r
+         *            la vue demandeuse de mise a jour
+         */
+        public void obtenirPhotoGalerie(Rafraichissable r) {
+                masquerChargement();
+                getIModele().obtenirNombrePhotoGalerie(r);
+        }
+        /**
+         * demande au modèle les métadonnées associées a une image
+         *
+         * @param r
+         *            la vue demandeuse de mise a jour
+         * @param id
+         *            l'identifiant de l'image
+         */
+        public void obtenirMetadonnees(Rafraichissable r, String id) {
+                getIModele().obtenirMetadonnees(r, id);
+        }
+        /**
+         * demande au modèle les ids des mots clés associés a une image
+         *
+         * @param r
+         *            la vue demandeuse de mise a jour
+         * @param id
+         *            l'identifiant de l'image
+         */
+        public void obtenirMotsClesId(Rafraichissable r, String id) {
+                getIModele().obtenirMotsClesId(r, id);
+        }
+        /**
+         * 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().obtenirArbreMotCle(r);
+        }
+        /**
+         * envoie au modèle une demande de mise a jour des informations modifiables
+         * associées a une image
+         *
+         * @param commentaires
+         *            le commentaire de l'image
+         * @param date
+         *            la date modifiée par l'utilisateur
+         */
+        public void mettreAJourInfo(String commentaires, String date, String note) {
+                String ids[] = getVueSelectionnee().getIdSelectionnees();
+                getIModele().mettreAJourCacheImage(commentaires, date, note, ids);
+                getListeImage().mettreAjourInfos(commentaires, date, note);
+        }
+        /**
+         * Met à jour l'arbre des mots clés affichés dans le volet de droite à
+         * partir de l'arbre passé en paramètre
+         *
+         * @param arbreMC
+         *            le nouvel arbre des mots clés
+         */
+        public void rafraichirArbreMotsCles(Tree arbreMC) {
+                metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false);
+                filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
+        }
+        /**
+         * envoie au modèle une demande pour lancer le formulaire ou l'application
+         * d'upload
+         */
+        public void uploaderImages() {
+                getIModele().uploaderImages();
+        }
+        /**
+         * 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) {
+                obtenirMetadonnees(metadonneesIptcExif, imgNum);
+                obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), imgNum);
+                obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum);
+        }
+        /**
+         * 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[] imgXY = getIModele().obtenirTailleImage(
+                                rd.getAsString("num_image"));
+                String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
+                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[] imgXY = getIModele().obtenirTailleImage(
+                                rd.getAsString("num_image"));
+                String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
+                getZoomImage().rafraichir(infosImage, false);
+                dernierIndexOnglet = 1;
+                obtenirDonnes(imgNum);
+        }
+        /**
+         * gestion du double clic dans la liste
+         *
+         * @param rowIndex
+         */
+        public void doubleClicListeImage(int rowIndex) {
+                clicListeImage(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());
+        }
+        /**
+         * 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[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
+                        getZoomImage().rafraichir(infosImage, false);
+                        if (getGalerieImage().isRendered()) {
+                                getGalerieImage().getDView().select(storeIndex);
+                        }
+                        if (getListeImage().isRendered()) {
+                                getListeImage().getSelectionModel().selectRecords(nRec);
+                        }
+                        obtenirDonnes(imgNum);
+                }
+        }
+        /**
+         * synchronise la selection entre la galerie et la liste
+         *
+         * @param string
+         *            le nom de la vue qui doit être synchronisee
+         */
+        public void synchroniserSelection(String string) {
+                if (string.equals("galerie") && getDernierIndexOnglet() != 2) {
+                        Record[] sel = getGalerieImage().getDView().getSelectedRecords();
+                        getListeImage().selectionnerEnregistrements(sel);
+                }
+                if (string.equals("liste") && getDernierIndexOnglet() != 0) {
+                        Record[] sel = getListeImage().getSelectionModel().getSelections();
+                        int[] ids = new int[sel.length];
+                        for (int i = 0; i < sel.length; i++) {
+                                ids[i] = getGalerieImage().getSt().indexOf(sel[i]);
+                        }
+                        getGalerieImage().selectionnerImages(ids);
+                }
+        }
+        /**
+         * fait une demande de suppression des images (en local et en distant) des
+         * images selectionnees
+         */
+        public void supprimerImages() {
+                String[] ids = null;
+                if (dernierIndexOnglet == 0) {
+                        ids = getGalerieImage().getIdSelectionnees();
+                } else {
+                        ids = getListeImage().getIdSelectionnees();
+                }
+                if (ids.length > 0) {
+                        if (com.google.gwt.user.client.Window
+                                        .confirm("Supprimer les images selectionnees ?")) {
+                                masquerChargement();
+                                getIModele().supprimerImages(ids);
+                                aucuneSelection();
+                        }
+                } else {
+                        Window.alert("Impossible de supprimer : aucune image selectionnee");
+                }
+        }
+        /**
+         * desactive les onglets de metadonnees et de zoom (dans le cas ou rien
+         * n'est selectionne)
+         */
+        public void aucuneSelection() {
+                if (getListeImage().getSelectionModel().getCount() <= 0
+                                && getGalerieImage().getDView().getSelectionCount() <= 0) {
+                        getZoomImage().disable();
+                        getMetadonneesIptcExif().desactiverPanneau();
+                        getZoomImage().desactiverPanneau();
+                        setSelection(false);
+                }
+        }
+        /**
+         * reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il
+         * n'y en avait pas)
+         */
+        public void selection() {
+                if (!isSelection()) {
+                        getMetadonneesIptcExif().activerPanneau();
+                        getZoomImage().activerPanneau();
+                        getZoomImage().enable();
+                        setSelection(true);
+                }
+        }
+        /**
+         * Fait apparaitre le menu contextuel de l'arbre des mots clés au niveau
+         * d'un noeud donné
+         *
+         * @param n
+         *            le noeud ou le menu doit apparaitre
+         * @param ev
+         *            l'objet contenant les données sur l'évenement
+         * @param te
+         *            l'éditeur associé à l'arbre qui permet de modifier les
+         *            libellés des noeuds
+         */
+        public void montrerContextMenuArbre(final TreeNode n, EventObject ev,
+                        final TreeEditor te) {
+                Menu mn = new Menu();
+                final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
+                                "Ajouter mot cle");
+                final com.gwtext.client.widgets.menu.Item suppN = new Item(
+                                "Supprimer mot cle");
+                mn.addItem(ajoutN);
+                mn.addItem(suppN);
+                mn.addListener(new MenuListenerAdapter() {
+                        public void onItemClick(BaseItem item, EventObject e) {
+                                if (item.equals(suppN)) {
+                                        getMetadonneesIptcExif().getPanneauMotsCles()
+                                                        .supprimerNoeud(n);
+                                }
+                                if (item.equals(ajoutN)) {
+                                        getMetadonneesIptcExif().getPanneauMotsCles().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();
+                getIModele().mettreAjourMotsCles(ids, motsClesEnCours, arbreMC);
+        }
+        /**
+         * Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots
+         * clés
+         *
+         * @param n
+         *            le noeud à ajouter à l'arbre
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                getIModele().ajouterMotCleDansArbre(n, arbreMC);
+                filtres.getMotsClesFiltre().rafraichir(n, false);
+        }
+        /**
+         * Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre
+         * dans l'arbre des mots clés
+         *
+         * @param n
+         *            le noeud à supprimer
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                getIModele().supprimerMotCleDansArbre(n, arbreMC);
+                filtres.getMotsClesFiltre().rafraichir(n.getId(), false);
+        }
+        /**
+         * Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots
+         * clés
+         *
+         * @param n
+         *            le noeud à modifier
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                getIModele().modifierMotCleDansArbre(n, arbreMC);
+                filtres.getMotsClesFiltre().rafraichir(n, false);
+        }
+        /**
+         * Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans
+         * l'arbre des mots clés
+         *
+         * @param n
+         *            le noeud à déplacer
+         * @param arbreMC
+         *            le nouvel arbre de mots clés à mettre à jour
+         */
+        public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                getIModele().deplacerMotCleDansArbre(n, arbreMC);
+                filtres.getMotsClesFiltre().rafraichir(n, false);
+        }
+        /**
+         * 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
+         */
+        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
+         */
+        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() {
+                ExtElement masked = Ext.get(getIdVueSelectionnee());
+                if (masked != null && !masked.isMasked()) {
+                        masked.mask("Chargement", true);
+                }
+        }
+        /**
+         * Recherche l'élement actuellement affiché et retire son message de
+         * chargement si l'était affiché
+         */
+        public void demasquerChargement() {
+                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();
+                for (int i = 0; i < valeursFiltres.length; i++) {
+                        if(valeursFiltres[i].equals(null))
+                        {
+                                Window.alert("Le filtre "+i+" est nul") ;
+                        }
+                        else
+                        {
+                                if(valeursFiltres[i][0].equals(null))
+                                {
+                                        Window.alert("Le nom du filtre "+i+" est nul") ;
+                                }
+                                if(valeursFiltres[i][1].equals(null))
+                                {
+                                        Window.alert("La valeur du filtre "+i+" est nulle") ;
+                                }
+                        }
+                }
+                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 PanneauFiltresVues getPanneauFiltres() {
+                return filtres;
+        }
+        /**
+         * ajoute les images séléctionnées dans la vue courante au tampon
+         */
+        public void ajouterImagesSelection() {
+                String[] ids = getVueSelectionnee().getIdSelectionnees();
+                String id = "";
+                for (int i = 0; i < ids.length; i++) {
+                        id += " - " + ids[i];
+                }
+                getIModele().ajouterImagesSelection(ids);
+                Window.alert(ids.length + " image(s) ajoutées au tampon ");
+        }
+        /**
+         * Affiche les ids des images contenues dans le tampon
+         */
+        public void afficherIdSelectionImages() {
+                Window.alert("Contenu du tampon : " + getIModele().renvoyerSelection());
+        }
+        /**
+         * Renvoie les ids des images contenues dans le tampon en une seule string
+         * @return une string de la forme id1, id2, id3
+         */
+        public String renvoyerSelection() {
+                return getIModele().renvoyerSelection();
+        }
+        /**
+         * Vide le tampon d'images
+         */
+        public void viderSelection() {
+                getIModele().viderSelection();
+                Window.alert("Le tampon a été vidé ");
+        }
+        /**
+         * 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 idObs = rddrop.getAsString("id_obs")+"," ;
+                        // on lie les observations
+                        lierImagesObservation(idObs, 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 ;
+                // 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
+                        int 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() ;
+                        int index = lv.getView().findRowIndex(e) ;
+                        rddrop = lv.getSt().getAt(index) ;
+                }
+                // si on a bien obtenu un enregistrement
+                if(rddrop != null)
+                {
+                        // on récupère l'id de l'image et alors on appelle la fonction de liaison
+                        String idImg = rddrop.getAsString("id_image")+"," ;
+                        lierImagesObservation(idsObs, idImg) ;
+                        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 ;
+        }
+        /**
+         * 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)
+        {
+                // TODO: faire une vraie liaison dans la base de données avec des vraies observations
+                getIModele().lierImagesObervations(idsObs,idsImg) ;
+                //Window.alert("Les observations suivantes : "+idsObs+" seront liées aux images suivantes : "+idsImg) ;
+        }
+}

 /trunk/src/org/tela_botanica/client/image/ImageModele.java
 New file
 ,0 → 1,849
+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.Configuration;
+import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
+import org.tela_botanica.client.modeles.ImageCarnet;
+import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;
+import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;
+import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
+import org.tela_botanica.client.modeles.ListeImageCarnet;
+import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
+import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;
+import com.google.gwt.json.client.JSONArray;
+import com.google.gwt.json.client.JSONObject;
+import com.gwtext.client.data.ArrayReader;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.IntegerFieldDef;
+import com.gwtext.client.data.MemoryProxy;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.widgets.tree.TreeNode;
+/**
+ * Modèle d'accès aux données pour les images. C'est un singleton
+ *
+ * @author aurelien
+ *
+ */
+public class ImageModele implements Rafraichissable {
+        /**
+         * Booleen indiquant si le médiateur est instancié (l'instance doit être
+         * unique donc le booleen est static)
+         */
+        private static boolean estInstancie = false;
+        /**
+         * le modèle lui même
+         */
+        private static ImageModele thisModele = null;
+        /**
+         * Le médiateur associé au modèle
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * La configuration en cours
+         */
+        private Configuration config = null;
+        /**
+         * La liste des image affichées en cours
+         */
+        private ListeImageCarnet cacheImage = new ListeImageCarnet(0);
+        /**
+         * Table de correspondance entre les mots clés et leurs identifiants
+         */
+        private HashMap<String, String> motsCles = new HashMap<String, String>(0);
+        /**
+         * Le store contenant les données à afficher, que le modèle transmet au
+         * médiateur quand il le demande
+         */
+        private Store st = null;
+        /**
+         * Arbre des mots clés
+         */
+        private com.gwtext.client.data.Tree arbreMotsCles = new Tree();
+        /**
+         * Numéro de page en cours
+         */
+        private int pageEncours = 0;
+        /**
+         * Nombre de pages totales
+         */
+        private int pageMax = 1;
+        /**
+         * Taille de page (par défaut 50)
+         */
+        private int taillePage = 50;
+        /**
+         * Nombre d'éléments total correspondant à la requete
+         */
+        private int nbElements = 0;
+        /**
+         * "Presse papier" pour les images qui permet de garder en mémoire une
+         * sélection
+         */
+        private Vector<String> selectionImages = new Vector<String>(0);
+        /**
+         * Retourne une instance de manière unique
+         *
+         * @param im
+         *            le médiateur à associer
+         * @return l'instance du modèle
+         */
+        static ImageModele Instance(ImageMediateur im) {
+                // si le modèle n'est pas encore instancié
+                if (!estInstancie) {
+                        // on en crée un nouveau
+                        estInstancie = true;
+                        thisModele = new ImageModele(im);
+                }
+                // sinon on retourne le "pointeur" vers le modèle lui-même
+                return thisModele;
+        }
+        /**
+         * Le constructeur est privé et seule la méthode instance y accède
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        private ImageModele(ImageMediateur im) {
+                iMediateur = im;
+                config = new Configuration();
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Appelle le DAO asynchrone pour obtenir la liste des images
+         *
+         * @param r
+         *            le rafraichissable auxquel on enverra les données
+         */
+        public void obtenirNombrePhotoGalerie(Rafraichissable r) {
+                String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
+                int tailleFiltres = valeursFiltres.length;
+                String[][] criteres = new String[tailleFiltres + 1][2];
+                String[] utilisateur = { "ci_ce_utilisateur",
+                                "" + getIMediateur().getIdentifiant() };
+                criteres[0] = utilisateur;
+                for (int i = 0; i < valeursFiltres.length; i++) {
+                        criteres[i + 1] = valeursFiltres[i];
+                }
+                // on les crée un DAO auquel on les transmet et qui demande le nombre
+                // d'images correspondantes (pour les pages)
+                NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
+                niaDAO.obtenirNombreImages(this, criteres);
+        }
+        public void obtenirPhotoGalerie(Rafraichissable r)
+        {
+                String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
+                int tailleFiltres = valeursFiltres.length;
+                String[][] criteres2 = new String[tailleFiltres + 2][2];
+                String[] limite = { "ci_limite", "" + taillePage };
+                String[] taillePage = { "ci_numero_page", "" + pageEncours };
+                criteres2[0] = limite;
+                criteres2[1] = taillePage;
+                for (int i = 0; i < valeursFiltres.length; i++) {
+                        criteres2[i + 2] = valeursFiltres[i];
+                }
+                // et on crée un DAO auquel on les transmet et qui envoie une requete
+                // pour recevoir les images
+                ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
+                liaDAO.ObtenirListeImages(this, criteres2);
+        }
+        /**
+         * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et
+         * lancer l'interface appropriée
+         */
+        @SuppressWarnings("static-access")
+        public void uploaderImages() {
+                ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
+                IuADaO.choisirMethodeUpload();
+        }
+        /**
+         * 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 = (ImageCarnet) 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) {
+                ImageCarnet im = cacheImage.get(id);
+                String motsClesId = im.getMotsCles();
+                String[] motsClesIdTab = motsClesId.split(",");
+                r.rafraichir(motsClesIdTab, false);
+        }
+        /**
+         * 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
+         */
+        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()][9];
+                        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.getDate();
+                                photoData[i][2] = im.getIptcCity();
+                                photoData[i][3] = im.getMake() + " " + im.getModel();
+                                photoData[i][4] = im.getSUrl();
+                                photoData[i][5] = im.getMUrl();
+                                photoData[i][6] = im.getLUrl();
+                                photoData[i][7] = im.getNote();
+                                photoData[i][8] = im.getId();
+                                i++;
+                        }
+                        // creation du store qui les contient
+                        FieldDef defNumImage = new IntegerFieldDef("num_image");
+                        FieldDef defDatImage = new StringFieldDef("dat_image");
+                        FieldDef defLieImage = new StringFieldDef("lie_image");
+                        FieldDef defAppImage = new StringFieldDef("app_image");
+                        FieldDef defUrlImageS = new StringFieldDef("url_image_S");
+                        FieldDef defUrlImageM = new StringFieldDef("url_image_M");
+                        FieldDef defUrlImage = new StringFieldDef("url_image");
+                        FieldDef defNoteImage = new IntegerFieldDef("note_image");
+                        FieldDef defIdImage = new IntegerFieldDef("id_image");
+                        FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
+                                        defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
+                                        defNoteImage, defIdImage };
+                        RecordDef rd = new RecordDef(defTab);
+                        final MemoryProxy dataProxy = new MemoryProxy(photoData);
+                        final ArrayReader reader = new ArrayReader(rd);
+                        final Store photoStore = new Store(dataProxy, reader);
+                        rafraichirListeImage(nouvelleDonnees);
+                        st = photoStore;
+                        st.load();
+                        // par défaut le store est trié sur le numéro d'image
+                        st.sort("num_image");
+                        // si on doit répandre les données, on notifie le médiateur qui les
+                        // distribuera à son tour
+                        if (repandreRafraichissement) {
+                                getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
+                        }
+                }
+                // si on reçoit un tableau JSON
+                if (nouvelleDonnees instanceof JSONArray) {
+                        // alors on a reçu les informations sur les mots clés
+                        JSONArray reponse = (JSONArray) nouvelleDonnees;
+                        final int taillemax = reponse.size();
+                        // si le tableau est vide
+                        if (taillemax == 0) {
+                                // on crée un arbre vide
+                                TreeNode root = new TreeNode();
+                                root.setId("racine");
+                                root.setText("Tags");
+                                String[] usObj = { "Tags", "racine" };
+                                root.setUserObject(usObj);
+                                arbreMotsCles.setRootNode(root);
+                        }
+                        // pour chacun des élements du tableau
+                        for (int j = 0; j < taillemax; j++) {
+                                // on extrait les élements du tableau
+                                if (reponse.get(j).isObject() != null) {
+                                        JSONObject noeud = (JSONObject) reponse.get(j);
+                                        String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")
+                                                        .isString().stringValue();
+                                        String mot_cle = noeud.get("cmc_mot_cle").isString()
+                                                        .stringValue();
+                                        String parent = noeud.get("cmc_id_parent").isString()
+                                                        .stringValue();
+                                        String[] usObj = { mot_cle, id_noeud };
+                                        // et on construit l'arbre à partir de la racine (qui est
+                                        // toujoursl e premier élément)
+                                        if (id_noeud.equals("racine")) {
+                                                TreeNode root = new TreeNode();
+                                                root.setId(id_noeud);
+                                                root.setText(mot_cle);
+                                                root.setUserObject(usObj);
+                                                arbreMotsCles.setRootNode(root);
+                                        } else {
+                                                // et en ajoutant les noeuds un à un (qui sont renvoyé
+                                                // dans l'ordre hierarchique de leur niveau
+                                                // ce qui permet de les traiter séquentiellement)
+                                                TreeNode node = new TreeNode();
+                                                node.setId(id_noeud);
+                                                node.setText(mot_cle);
+                                                node.setChecked(false);
+                                                Node parentNode = arbreMotsCles.getNodeById(parent);
+                                                node.setUserObject(usObj);
+                                                parentNode.appendChild(node);
+                                        }
+                                }
+                        }
+                        // 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
+                        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) ;
+                }
+        }
+        /**
+         * Affiche les paires / valeur de tous les mots clés stockés
+         */
+        public void afficherMotsCles() {
+                for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
+                        String key = it.next();
+                        String valeur = (String) motsCles.get(key);
+                        System.out.println("clé : " + key + " valeur : " + valeur);
+                }
+        }
+        /**
+         * Met à jour les mots clés associés à une image et appelle le DAO pour
+         * synchroniser la base de données
+         *
+         * @param ids
+         *            les identifiants des images selectionnées
+         * @param motsClesEnCours
+         *            les mots clés à appliquer aux images
+         * @param arbreMC
+         *            l'arbre de mots clés en cours
+         */
+        public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
+                        com.gwtext.client.data.Tree arbreMC) {
+                for (int i = 0; i < ids.length; i++) {
+                        if (cacheImage.containsKey(ids[i])) {
+                                ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);
+                                ic.mettreAjourMotsCles(motsClesEnCours);
+                                ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this);
+                                imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic);
+                        }
+                }
+                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(this);
+                MCDao.obtenirListeMotsCles(this);
+        }
+        /**
+         * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable
+         * donné, qui le demande
+         *
+         * @param r
+         *            le rafraichissable demandeur de l'arbre
+         */
+        public void obtenirArbreMotCle(Rafraichissable r) {
+                r.rafraichir(arbreMotsCles, false);
+        }
+        /**
+         * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
+         * fait la mise à jour de l'arbre des mots clés dans la base
+         *
+         * @param n
+         *            le nouveau noeud contenant le mot clé
+         * @param arbreMC
+         *            l'arbre des mots cles en cours
+         */
+        public void ajouterMotCleDansArbre(TreeNode n,
+                        com.gwtext.client.data.Tree arbreMC) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
+                String[] usObj = (String[]) n.getUserObject();
+                String motCle = usObj[0];
+                String id = usObj[1];
+                String parentId = "";
+                if (!id.equals("racine")) {
+                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
+                        parentId = parentUsObj[1];
+                } else {
+                        parentId = "racine";
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
+                                + motCle + "&id=" + id + "&parent=" + parentId;
+                MCDao.ajouterBaseDeDonnees(nouveauMotCle);
+        }
+        /**
+         * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
+         * supprimer les mots clés associés dans la base
+         *
+         * @param n
+         *            le noeud à supprimer
+         * @param arbreMC
+         *            l'arbre des mots clés en cours
+         */
+        public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
+                String[] usObj = (String[]) n.getUserObject();
+                String id = usObj[1];
+                MCDao.supprimerBaseDeDonnees(id);
+        }
+        /**
+         * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
+         * DAO qui synchronise la modification dans la base de données
+         *
+         * @param n
+         *            le noeud modifié
+         * @param arbreMC
+         *            l'arbre des mots clés en cours
+         */
+        public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
+                String[] usObj = (String[]) n.getUserObject();
+                String motCle = usObj[0];
+                String id = usObj[1];
+                String parentId = "";
+                if (!id.equals("racine")) {
+                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
+                        parentId = parentUsObj[1];
+                } else {
+                        parentId = "racine";
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.modifierBaseDeDonnees(motCleModifie);
+        }
+        /**
+         * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
+         * reorganise l'arbre dans la base de donnees suivant le changement
+         *
+         * @param n
+         *            le noeud deplace (et son sous arbre associe)
+         * @param arbreMC
+         *            l'arbre des mots cles en cours
+         */
+        public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
+                MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
+                String[] usObj = (String[]) n.getUserObject();
+                String motCle = usObj[0];
+                String id = usObj[1];
+                String parentId = "";
+                if (!id.equals("racine")) {
+                        String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
+                        parentId = parentUsObj[1];
+                } else {
+                        parentId = "racine";
+                }
+                rafraichirArbreMotsCles(arbreMC);
+                String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+                                + parentId;
+                MCDao.deplacerBaseDeDonnees(motCleModifie);
+        }
+        /**
+         * Change le numéro de la page en cours et envoie une demande de mise à jour
+         * des données
+         *
+         * @param nouvellePageCourante
+         *            la nouvelle page à afficher
+         */
+        public void changerNumeroPage(int nouvellePageCourante) {
+                pageEncours = nouvellePageCourante;
+                obtenirNombrePhotoGalerie(this);
+        }
+        /**
+         * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
+         * donnés en fonction de la taille de page en cours
+         *
+         * @param nbElements
+         *            le nombre d'élements total
+         * @return le nombre de pages
+         */
+        public int calculerNbPages(int nbElements) {
+                // A cause de la betise de java pour les conversion implicite on fait
+                // quelques conversions manuellement
+                // pour eviter qu'il arrondisse mal la division
+                // nombre de pages = (nombre d'element / taille de la page) arrondie à
+                // l'entier superieur
+                double nPage = (1.0 * nbElements) / (1.0 * taillePage);
+                double nPageRound = Math.ceil(nPage);
+                Double nPageInt = new Double(nPageRound);
+                // on convertit en entier
+                return nPageInt.intValue();
+        }
+        /**
+         * Recalcule la page en cours lors du changement du nombre d'élements
+         *
+         * @param nbElements
+         *            le nombre d'élements total
+         * @return la nouvelle page encours
+         */
+        public int calculerPageCourante(int nbElements) {
+                // on calcule le nombre de page
+                int nouvelNbPages = calculerNbPages(nbElements);
+                // la nouvelle page en cours
+                double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
+                                * (1.0 * nouvelNbPages);
+                // on arrondit au supérieur
+                double nPageRound = Math.ceil(nPageCourante);
+                Double nPageInt = new Double(nPageRound);
+                // on convertit en entier
+                return Math.abs(nPageInt.intValue());
+        }
+        /**
+         * Change la taille de page et recalcule la page encours
+         *
+         * @param nouvelleTaillePage
+         *            la nouvelle taille de page à utiliser
+         */
+        public void changerTaillePage(int nouvelleTaillePage) {
+                taillePage = nouvelleTaillePage;
+                pageEncours = calculerPageCourante(nbElements);
+                obtenirNombrePhotoGalerie(this);
+        }
+        /**
+         * 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++) {
+                        selectionImages.add(ids[i]);
+                }
+        }
+        /**
+         * 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) ;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/MenuIdVue.java
 New file
 ,0 → 1,83
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.widgets.menu.BaseItem;
+import com.gwtext.client.widgets.menu.Item;
+import com.gwtext.client.widgets.menu.Menu;
+import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
+public class MenuIdVue extends Menu {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur;
+        /**
+         * Item pour le changement d'utilisateur
+         */
+        private Item changerId = null;
+        /**
+         * Constructeur sans argument (privé car ne doit être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private MenuIdVue() {
+                super();
+        }
+        /**
+         * Constructeur avec paramètre
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public MenuIdVue(ImageMediateur im) {
+                super();
+                iMediateur = im;
+                // on construit le menu
+                changerId = new Item("Changer d'utilisateur");
+                addItem(changerId);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners pour la gestions des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new MenuListenerAdapter() {
+                        // gestion du clic sur un item
+                        public void onItemClick(BaseItem item, EventObject e) {
+                                // si c'est la recherche par commentaires
+                                if (item.equals(changerId)) {
+                                        // on notifie le médiateur
+                                        getIMediateur().afficherMenuId();
+                                }
+                                // enfin, on cache le menu
+                                hide();
+                        }
+                });
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/BarrePaginationObservationVue.java
 New file
 ,0 → 1,408
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.observation.ObservationMediateur;
+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 BarrePaginationObservationVue extends Toolbar implements Rafraichissable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ObservationMediateur    observationMediateur            = null;
+        /**
+         * Bouton précédent
+         */
+        private ToolbarButton prevPage = new ToolbarButton("<<") ;
+        /**
+         * Bouton suivant
+         */
+        private ToolbarButton suivPage = new ToolbarButton(">>") ;
+        /**
+         * Numéro de la page courante (attention, commence à zéro pour des raisons pratiques)
+         */
+        private int pageCourante = 0 ;
+        /**
+         * Nombre de page total
+         */
+        private int pageTotale = 1 ;
+        /**
+         * Nombre d'élements total
+         */
+        private int nbElement = 0 ;
+        /**
+         * Nombre d'élément par page
+         */
+        private int taillePage = 0 ;
+        /**
+         * Texte statique de la toolbar 1
+         */
+        private ToolbarTextItem page = new ToolbarTextItem("Page ") ;
+        /**
+         * Affichage de la page courante
+         */
+        private TextField champPage = new TextField(""+(pageCourante+1)) ;
+        /**
+         * Affichage de "sur pageTotale "
+         */
+        private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "+pageTotale) ;
+        /**
+         * Texte statique de la toolbar 2
+         */
+        private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ") ;
+        /**
+         * Combobox permettant de selectionner le nombre d'élements à afficher par page
+         * et donc de changer la variable taillePage
+         */
+        private ComboBox selecteurTaillePage = new ComboBox() ;
+        /**
+         * Texte statique de la toolbar 3
+         */
+        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ;
+        /**
+         * Affiche l'intervalle des éléments contenus dans la page
+         */
+        private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ;
+        /**
+         * retourne le mediateur associe à la barre
+         */
+        public ObservationMediateur getImediateur()
+        {
+                return observationMediateur;
+        }
+        /***
+         * constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        private  BarrePaginationObservationVue()
+        {
+                super() ;
+        }
+        /**
+         * constructeur avec paramètres
+         * @param im le médiateur à associer à la barre
+         */
+        public BarrePaginationObservationVue(ObservationMediateur im)
+        {
+                super() ;
+                observationMediateur = im ;
+                // 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) ;
+                // le store contient les valeur possibles pour les tailles de page
+                final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());
+                store.load();
+                // 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(store) ;
+                selecteurTaillePage.setWidth(40) ;
+                selecteurTaillePage.setEditable(false) ;
+                addField(selecteurTaillePage) ;
+                selecteurTaillePage.setValue("20") ;
+                selecteurTaillePage.setWidth(50) ;
+                addItem(nbElemParPage) ;
+                // on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
+                addFill() ;
+                addItem(intervalleElements) ;
+                addSpacer() ;
+                // on ajoute les différents listeners
+                ajouterListeners() ;
+        }
+        /**
+         * ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination
+         */
+        private void ajouterListeners()
+        {
+                // boutons suivants et précédents
+                prevPage.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                // si la page courante n'est pas la première
+                                if(pageCourante > 0)
+                                {
+                                        // on décrémente la page courante de 1
+                                        pageCourante -- ;
+                                        // on rafraichit l'affichage
+                                        rafraichirNumeroPage() ;
+                                        // et on notifie le médiateur de l'évenement
+                                        observationMediateur.changerNumeroPage(pageCourante) ;
+                                }
+                        }
+                }) ;
+                suivPage.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                // si la page courante n'est pas la dernière
+                                if(pageCourante  < pageTotale -1)
+                                {
+                                        // on incrémente la page courante de 1
+                                        pageCourante ++ ;
+                                        // on rafraichit l'affichage
+                                        rafraichirNumeroPage() ;
+                                        // et on notifie le médiateur de l'évenement
+                                        observationMediateur.changerNumeroPage(pageCourante) ;
+                                }
+                        }
+                }) ;
+                champPage.addListener(new TextFieldListenerAdapter() {
+                        public void onSpecialKey(Field field, EventObject e) {
+                                // on teste si la touche entrée a été pressée
+                                if(e.getKey() == EventObject.ENTER)
+                                {
+                                        int nouvellePage = pageCourante ;
+                                        // on teste avec parseInt si la valeur entrée est un entier
+                                         try
+                                         {
+                                                nouvellePage = Integer.parseInt(champPage.getRawValue()) ;
+                                         }
+                                         // si ce n'est pas le cas alors on remet le numéro de page correct
+                                         catch(NumberFormatException nfe)
+                                         {
+                                                 rafraichirNumeroPage() ;
+                                                 champPage.focus(true) ;
+                                                 return ;
+                                         }
+                                        // si la conversion reussit on verifie s'il est nécessaire de changer de page
+                                        // et si la nouvelle est comprise dans l'intervalle des pages existantes (0..pageTotale)
+                                        if(nouvellePage != pageCourante + 1 && nouvellePage > 0 && nouvellePage <= pageTotale)
+                                        {
+                                                        // le cas échéant, on charge la nouvelle page et on notifie le médiateur
+                                                        changerPageCourante(nouvellePage - 1) ;
+                                                        observationMediateur.changerNumeroPage(pageCourante);
+                                        }
+                                        else
+                                        {
+                                                // sinon on reaffiche l'ancien numero de page sans rien changer
+                                                rafraichirNumeroPage() ;
+                                                champPage.focus(true) ;
+                                        }
+                                }
+                        }
+                        public void onFocus(Field field) {
+                                champPage.focus(true) ;
+                        }
+                });
+                // pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
+                champPage.addKeyPressListener(new EventCallback() {
+                        public void execute(EventObject e) {
+                                // si c'est un numerique
+                                if(Character.isDigit((char)e.getCharCode()))
+                                {
+                                        // on laisse passer
+                                        return ;
+                                }
+                                // si c'est la touche entrée ou backspace (valider ou effacer)
+                                if(e.getKey() == EventObject.ENTER || e.getKey() == EventObject.BACKSPACE)
+                                {
+                                        // on laisse passer
+                                        return ;
+                                }
+                                else
+                                {
+                                        // sinon on remet le numero de page correct et on annule l'évenement
+                                        rafraichirNumeroPage() ;
+                                        e.stopEvent() ;
+                                }
+                        }
+                }) ;
+                // listener pour la selection dans la combobox
+                selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
+                        public void onSelect(ComboBox comboBox, Record record, int index) {
+                                String nouvelleTaillePageString = comboBox.getStore().getRecordAt(index).getAsString("nb_page") ;
+                                int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString) ;
+                                // si la taille de page est différente de l'ancienne
+                                if(nouvelleTaillePage != taillePage)
+                                {
+                                        // on la change
+                                        changerTaillePage(nouvelleTaillePage) ;
+                                }
+                                // et on met la valeur à jour dans la combobox
+                                comboBox.setValue(nouvelleTaillePageString) ;
+                        }
+                }) ;
+        }
+        /**
+         * Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments
+         * à partir des variables de classes
+         */
+        public void rafraichirNumeroPage()
+        {
+                surTotalPage.setText(" sur "+pageTotale) ;
+                if(nbElement == 0)
+                {
+                        champPage.setValue(""+(0)) ;
+                        // on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
+                        intervalleElements.setText("Observations 0 - 0 sur 0") ;
+                }
+                else
+                {
+                        champPage.setValue(""+(pageCourante+1)) ;
+                        // si la page n'est pas la dernière
+                        if(pageCourante + 1 != pageTotale)
+                        {
+                                // sauf pour la dernière page qui contient souvent moins d'élements que le nombre d'élements par page
+                                intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+(pageCourante+1)*taillePage+" sur "+nbElement) ;
+                        }
+                        else
+                        {
+                                // on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
+                                intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+nbElement+" sur "+nbElement) ;
+                        }
+                }
+        }
+        /**
+         * Met à jour la page en cours
+         * @param nouvellePageCourante la nouvelle page en cours
+         */
+        public void changerPageCourante(int nouvellePageCourante)
+        {
+                pageCourante = nouvellePageCourante ;
+        }
+        /**
+         * Methode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                // si on reçoit un tableau de int
+                if(nouvelleDonnees instanceof int[])
+                {
+                        int [] page = (int[])nouvelleDonnees ;
+                        // le premier élement est le nombre de pages totales
+                        pageTotale = page[0] ;
+                        // le second la page en cours
+                        pageCourante = page[1] ;
+                        // le troisième la taille de la page
+                        taillePage = page[2] ;
+                        // et le dernier le nombre total d'éléments
+                        nbElement = page[3] ;
+                        // si la page courante dépasse la page totale (cas normalement improbable car géré en amont)
+                        // on met le numéro de page à la page courante -1 (car la page courante est comptée à partir
+                        // de zéro)
+                        if(pageCourante >= pageTotale && pageCourante != 0)
+                        {
+                                pageCourante = pageTotale - 1 ;
+                                // le cas échéant on en notifie le médiateur
+                                observationMediateur.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 tableau de string qui contient les différentes taille de pages
+         */
+        public String[][] getNbPages()
+        {
+                String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ;
+                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) {
+                observationMediateur.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) ;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/DateFiltreVue.java
 New file
 ,0 → 1,149
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Filtrable;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.ui.Label;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.form.DateField;
+/**
+ * Classe implémentant un filtre qui permet de rechercher une image par rapport
+ * à la date associée, des critères plus fins viendront compléter cela
+ *
+ * @author aurelien
+ *
+ */
+public class DateFiltreVue extends Panel implements Rafraichissable, Filtrable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Le widget calendrier
+         */
+        private DateField filtreDate = null;
+        /**
+         * Booleen d'état du filtre
+         */
+        private boolean filtreModifie = false;
+        /**
+         * Constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private DateFiltreVue() {
+                super();
+        }
+        /**
+         * Constructeur avec arguments
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public DateFiltreVue(ImageMediateur im) {
+                super();
+                setPaddings(5);
+                setCollapsible(true);
+                setBorder(false);
+                iMediateur = im;
+                Label labelRecherche = new Label("Date :");
+                add(labelRecherche);
+                // on crée le calendrier et on définit le format de la date "jj/mm/aaaa"
+                filtreDate = new DateField();
+                filtreDate.setAutoWidth(true);
+                filtreDate.setFormat("d/m/Y");
+                add(filtreDate);
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners
+         */
+        public void ajouterListeners() {
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                filtreModifie = false;
+        }
+        /**
+         * Méthode héritée de l'interface filtrable
+         */
+        public void valider() {
+                filtreModifie = true;
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        @SuppressWarnings("unused")
+        private ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Méthode héritée de l'interface filtrable
+         */
+        public boolean renvoyerEtatFiltre() {
+                return filtreModifie;
+        }
+        /**
+         * Méthode héritée de l'interface filtrable
+         */
+        public String renvoyerNomFiltre() {
+                return "Recherche par date";
+        }
+        /**
+         * Méthode héritée de l'interface filtrable
+         */
+        public String[] renvoyerValeursAFiltrer() {
+                // si la date est valide
+                if (filtreDate.isValid()) {
+                        // on en sépare les composants
+                        String dt = filtreDate.getRawValue();
+                        String[] dates = dt.split("/");
+                        if (dates.length == 3) {
+                                // qu'on réassemble dans un autre format (américain) pour la
+                                // base de donnée "aaaa-mm-jj"
+                                String dateFormatee = dates[2] + "-" + dates[1] + "-"
+                                                + dates[0];
+                                String[] valeursFiltres = { "ci_meta_date", dateFormatee };
+                                return valeursFiltres;
+                        }
+                }
+                // si la date n'estp as valide on renvoie une chaine vide (ce qui
+                // correspond à n'importe qu'elle date)
+                String dateFormatee = "";
+                String[] valeursFiltres = { "ci_meta_date", dateFormatee };
+                return valeursFiltres;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ListeImageVue.java
 New file
 ,0 → 1,513
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.interfaces.VueListable;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.IntegerFieldDef;
+import com.gwtext.client.data.Record;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+import com.gwtext.client.dd.DragData;
+import com.gwtext.client.dd.DragSource;
+import com.gwtext.client.dd.DropTarget;
+import com.gwtext.client.dd.DropTargetConfig;
+import com.gwtext.client.widgets.Component;
+import com.gwtext.client.widgets.event.ContainerListenerAdapter;
+import com.gwtext.client.widgets.grid.CellMetadata;
+import com.gwtext.client.widgets.grid.ColumnConfig;
+import com.gwtext.client.widgets.grid.ColumnModel;
+import com.gwtext.client.widgets.grid.GridDragData;
+import com.gwtext.client.widgets.grid.GridPanel;
+import com.gwtext.client.widgets.grid.Renderer;
+import com.gwtext.client.widgets.grid.RowSelectionModel;
+import com.gwtext.client.widgets.grid.event.GridRowListener;
+import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
+/**
+ * Liste d'image composée de miniatures et d'information sur l'image, implémente
+ * l'interface rafraichissable et l'interface vueListable
+ *
+ * @author aurelien
+ */
+public class ListeImageVue extends GridPanel implements Rafraichissable,
+                VueListable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig numImage;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig urlImage;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig lieImage;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig datImage;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig appImage;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig noteImage;
+        /**
+         * 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 pageToolBarVue bt = null;
+        /**
+         * 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 pageToolBarVue(iMediateur);
+                setBottomToolbar(bt);
+                // on construit le modèle de colonnes
+                numImage = new ColumnConfig("numéro", "num_image", 30, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                String ImgNum = record.getAsString("num_image");
+                                                return "<div class=\"centered-list\">" + ImgNum
+                                                                + "</div>";
+                                        }
+                                });
+                datImage = new ColumnConfig("date", "dat_image", 120, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                String ImgDat = record.getAsString("dat_image");
+                                                if (ImgDat == null) {
+                                                        ImgDat = " ";
+                                                }
+                                                return "<div class=\"centered-list\">" + ImgDat
+                                                                + "</div>";
+                                        }
+                                });
+                lieImage = new ColumnConfig("lieu", "lie_image", 120, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                String ImgLie = record.getAsString("lie_image");
+                                                if (ImgLie == null) {
+                                                        ImgLie = " ";
+                                                }
+                                                return "<div class=\"centered-list\">" + ImgLie
+                                                                + "</div>";
+                                        }
+                                });
+                appImage = new ColumnConfig("appareil", "app_image", 120, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                String ImgApp = record.getAsString("app_image");
+                                                if (ImgApp == null) {
+                                                        ImgApp = " ";
+                                                }
+                                                return "<div class=\"centered-list\">" + ImgApp
+                                                                + "</div>";
+                                        }
+                                });
+                // la colonne url possède une méthode de rendu spéciale
+                urlImage = new ColumnConfig("Image", "url_image_S", 30, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                // on affiche une div contenant l'image pointée par
+                                                // l'url
+                                                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 + "'> </div>";
+                                        }
+                                });
+                noteImage = new ColumnConfig("note", "note_image", 80, true,
+                                new Renderer() {
+                                        public String render(Object value,
+                                                        CellMetadata cellMetadata, Record record,
+                                                        int rowIndex, int colNum, Store store) {
+                                                String htmlImage = "";
+                                                int noteImg = record.getAsInteger("note_image");
+                                                if (noteImg >= 0) {
+                                                        htmlImage += "<div class=\"img-note centered-list\">";
+                                                        for (int i = 0; i <= noteImg; i++) {
+                                                                htmlImage += "<img src=\"note-on.gif\">";
+                                                        }
+                                                        htmlImage += "</div>";
+                                                }
+                                                return htmlImage;
+                                        }
+                                });
+                // on associe le modèle de colonnes
+                ColumnConfig[] cm = { numImage, urlImage, datImage, lieImage, appImage,
+                                noteImage };
+                modeleColonnes = new ColumnModel(cm);
+                this.setColumnModel(modeleColonnes);
+                this.setAutoScroll(true);
+                this.setAutoWidth(true);
+                this.setEnableColumnResize(true);
+                // creation du store
+                FieldDef defNumImage = new IntegerFieldDef("num_image");
+                FieldDef 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[] defTab = { defNumImage, defDatImage, defLieImage,
+                                defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
+                                defNoteImage };
+                RecordDef rd = new RecordDef(defTab);
+                st = new Store(rd);
+                // on associe le store
+                this.setStore(st);
+                this.getView().setAutoFill(true);
+                // on crée un masque de chargement qui s'affichera lors des mises à jour
+                this.setLoadMask("chargement");
+                //Enable drag and drop
+                this.setEnableDragDrop(true);
+                //You need to set the same group for both grids
+                this.setDdGroup("DragGroupName");
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners pour la gestion des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new ContainerListenerAdapter() {
+                        public void onHide(Component component) {
+                        }
+                        // lors du premier rendu on demande les données qui sont déjà
+                        // contenues dans la galerie qui est le premier élément affiché
+                        public void onRender(Component component) {
+                                if (!isEstInstancie()) {
+                                        setEstInstancie(true);
+                                        setDragDropText("Glissez les images sur la liste d'observation pour les lier") ;
+                                        getIMediateur().synchroniserSelection("galerie");
+                                }
+                        }
+                        public void onShow(Component component) {
+                        }
+                });
+                this.addGridRowListener(new GridRowListener() {
+                        // gestion du clic sur une ligne
+                        public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {
+                                // on notifie le médiateur et on lui passe le nuémro de ligne
+                                getIMediateur().clicListeImage(rowIndex);
+                        }
+                        // gestion du clic droit
+                        public void onRowContextMenu(GridPanel grid, int rowIndex,
+                                        EventObject e) {
+                                // on stoppe l'évenement pour empecher le navigateur d'afficher
+                                // son propre menu
+                                e.stopEvent();
+                                // on notifie le médiateur en lui passant l'évenement
+                                getIMediateur().montrerContextMenu(e);
+                        }
+                        // gestion du double clic
+                        public void onRowDblClick(GridPanel grid, int rowIndex,
+                                        EventObject e) {
+                                // on notifie le médiateur en lui passant le numéro de ligne
+                                getIMediateur().doubleClicListeImage(rowIndex);
+                        }
+                });
+                this.getSelectionModel().addListener(new RowSelectionListenerAdapter() {
+                        // gestion de la sélection
+                        public void onSelectionChange(RowSelectionModel sm) {
+                                // si on a rien de sélectionné
+                                if (sm.getCount() <= 0) {
+                                        // on notifie le médiateur (qui désactive notamment l'accès
+                                        // à certaines infos)
+                                        getIMediateur().aucuneSelection();
+                                } else {
+                                        // sinon on notifie le médiateur
+                                        getIMediateur().selection();
+                                        // et on lui demande de synchroniser la selection avec les
+                                        // autres vues
+                                        getIMediateur().synchroniserSelection("liste");
+                                }
+                        }
+                });
+                //Enable drag and drop
+                this.setEnableDragDrop(true);
+                //Same name in destination
+                this.setDdGroup("DragGroupName");
+                DropTargetConfig dtc = new DropTargetConfig();
+                dtc.setdDdGroup("DragGroupName");
+                //Now this is the important part, you need a drop target
+                @SuppressWarnings("unused")
+                DropTarget tg = new DropTarget(this, dtc)
+                {
+                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){
+                                if(data instanceof GridDragData)
+                                {
+                                        GridDragData gdd = (GridDragData)data ;
+                                if(gdd.getGrid().getId().equals("listeImageGrid"))
+                                {
+                                        return false ;
+                                }
+                                else
+                                {
+                                        return iMediateur.lierObsDD(source, e, data, getId()) ;
+                                }
+                                }
+                                else
+                                {
+                                        return false ;
+                                }
+                        }
+                        public String notifyOver(DragSource source, EventObject e, DragData data){
+                            return "x-dd-drop-ok";
+                        }
+                };
+        }
+        /**
+         * Méthode héritée de l'interface VueListable Sélectionne les images dans la
+         * galerie suivant les identifiants donnés en paramètres
+         */
+        public String[] getIdSelectionnees() {
+                Record[] selection = this.getSelectionModel().getSelections();
+                int taille = selection.length;
+                String id_selection[] = new String[taille];
+                for (int i = 0; i < selection.length; i++) {
+                        id_selection[i] = selection[i].getAsString("num_image");
+                }
+                return id_selection;
+        }
+        /**
+         * Accesseur pour la config de colonnes
+         *
+         * @return la config de colonnes
+         */
+        public ColumnConfig getCl() {
+                return cl;
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Accesseur pour le modèle de colonnes
+         *
+         * @return le modèle de colonnes
+         */
+        public ColumnModel getModeleColonnes() {
+                return modeleColonnes;
+        }
+        /**
+         * Accesseur pour le store
+         *
+         * @return le store contenant les données
+         */
+        public Store getSt() {
+                return st;
+        }
+        /**
+         * Accesseur pour le booleen d'instanciation
+         *
+         * @return le booleen d'instanciation
+         */
+        public boolean isEstInstancie() {
+                return estInstancie;
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         *
+         * @param nouvelleDonnees
+         *            les nouvelles données
+         * @param repandreRafraichissement
+         *            le booleen de notification du rafraichissement
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si on reçoit un store
+                if (nouvelleDonnees instanceof Store) {
+                        // on affecte celui-ci comme gestionnaire de données
+                        st = (Store) nouvelleDonnees;
+                        st.load();
+                        // et on reconfigure et rafraichit la vue
+                        this.reconfigure(st, this.getColumnModel());
+                }
+                // si on doit répandre l'évenement
+                if (repandreRafraichissement) {
+                        // on notifie le médiateur avec une copie des données
+                        getIMediateur().synchroniserDonneesZoomListeGalerie(
+                                        nouvelleDonnees, this);
+                }
+        }
+        /**
+         * Sélectionne des enregistrements donné
+         *
+         * @param sel
+         *            un tableau d'enregistrement à selectionner
+         */
+        public void selectionnerEnregistrements(Record[] sel) {
+                if (isEstInstancie()) {
+                        getSelectionModel().clearSelections();
+                        getSelectionModel().selectRecords(sel);
+                }
+        }
+        /**
+         * Accesseur pour la toolbar de pagination
+         *
+         * @return la toolbar de pagination
+         */
+        public pageToolBarVue 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);
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ZoomImageVue.java
 New file
 ,0 → 1,455
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.ClickListener;
+import com.google.gwt.user.client.ui.Image;
+import com.google.gwt.user.client.ui.Widget;
+import com.gwtext.client.core.EventObject;
+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.event.PanelListenerAdapter;
+import com.gwtext.client.widgets.grid.GridDragData;
+import com.gwtext.client.widgets.layout.BorderLayout;
+import com.gwtext.client.widgets.layout.BorderLayoutData;
+/**
+ * Panneau d'affichage d'une image avec des boutons précdents et suivant
+ *
+ * @author aurelien
+ *
+ */
+public class ZoomImageVue extends Panel implements Rafraichissable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Panneau conteneur pour l'image
+         */
+        private Panel imageConteneur = null;
+        /**
+         * l'image à afficher
+         */
+        private Image image = new Image("vide.jpg");
+        /**
+         * Bouton précédent
+         */
+        private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
+        /**
+         * Bouton suivant
+         */
+        private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
+        /**
+         * Taille originale Y de l'image
+         */
+        private int imageHeight = 0;
+        /**
+         * Taille originale X de l'image
+         */
+        private int imageWidth = 0;
+        /**
+         * Identifiant de l'image
+         */
+        private String idImage = "0" ;
+        /**
+         * Booleen d'initalisation général
+         */
+        private boolean initialise = false;
+        /**
+         * Booleen d'initalisation du conteneur d'image
+         */
+        private boolean conteneurInitialise = false;
+        /**
+         * 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() {
+                        public void onBrowserEvent(Event event) {
+                                // lors du double clic
+                                if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
+                                        // on notifie le médiateur
+                                        getIMediateur().doubleClicZoomImage();
+                                }
+                                // 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();
+                                        }
+                                }
+                        }
+                };
+                this.setHeader(false);
+                imageConteneur = new Panel() ;
+                imageConteneur.setBorder(false);
+                imageConteneur.add(image);
+                imageConteneur.setId("x-view-zoom-img");
+                // il n'existe pas de méthode pour ajouter un listener pour le double
+                // clic sur une image
+                // alors on lui dit manuellement de capter l'évènement double clic
+                image.sinkEvents(Event.ONDBLCLICK);
+                image.sinkEvents(Event.ONMOUSEWHEEL);
+                // l'image de base est vide
+                image.setUrl("vide.jpg");
+                this.setLayout(new BorderLayout());
+                prev.setWidth("60px");
+                suiv.setWidth("60px");
+                this.add(prev, new BorderLayoutData(RegionPosition.WEST));
+                this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
+                this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
+                imageConteneur.setMaskDisabled(true);
+                this.setBorder(false);
+                conteneurInitialise = true;
+                initialise = true;
+                configDragAndDrop() ;
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         *
+         * @param nouvelleDonnees
+         *            les nouvelles données
+         * @param repandreRafraichissement
+         *            le booleen qui dit si on doit répnadre l'évènement
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si on reçoit une string
+                if (nouvelleDonnees instanceof String[] && initialise
+                                && conteneurInitialise) {
+                        String[] infos = (String[]) nouvelleDonnees;
+                        // c'est l'url de l'image qu'on associe à la vue
+                        if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
+                                getImage().setUrl(infos[0]);
+                                int x = Integer.parseInt(infos[1]);
+                                int y = Integer.parseInt(infos[2]);
+                                setTailleImage(x, y);
+                                setIdImage(infos[3]) ;
+                                verifierEtRetaillerImage();
+                        }
+                } else {
+                        // sinon on met une image vide
+                        getImage().setUrl("vide.jpeg");
+                }
+        }
+        /**
+         * Desactive visuellement le panneau et les boutons
+         */
+        public void desactiverPanneau() {
+                getImage().setUrl("vide.jpeg");
+                prev.setEnabled(false);
+                suiv.setEnabled(false);
+        }
+        /**
+         * Active visuellement le panneau et les boutons
+         */
+        public void activerPanneau() {
+                prev.setEnabled(true);
+                suiv.setEnabled(true);
+        }
+        /**
+         * Ajoute les listeners pour la gestions d'évènement
+         */
+        public void ajouterListeners() {
+                // gestion du clic sur le bouton précedent
+                prev.addClickListener(new ClickListener() {
+                        // en cas de clic
+                        public void onClick(Widget sender) {
+                                // on notifie le médiateur
+                                getIMediateur().clicBoutonZoomImage("prev");
+                        }
+                });
+                // gestion du clic sur le bouton suivant
+                suiv.addClickListener(new ClickListener() {
+                        // en cas de clic
+                        public void onClick(Widget sender) {
+                                // on notifie le médiateur
+                                getIMediateur().clicBoutonZoomImage("suiv");
+                        }
+                });
+                // gestion du redimensionnement
+                this.addListener(new PanelListenerAdapter() {
+                        // lors d'un redimensionnement de l'application
+                        public void onBodyResize(Panel panel, java.lang.String width,
+                                        java.lang.String height) {
+                                // on vérifie et on retaille l'image
+                                verifierEtRetaillerImage();
+                        }
+                });
+                // gestion du redimensionnement lors de l'affichage du conteneur
+                imageConteneur.addListener(new PanelListenerAdapter() {
+                        // avant de finir d'afficher
+                        public void onAfterLayout(Container self) {
+                                // on redimensionne
+                                verifierEtRetaillerImage();
+                        }
+                });
+        }
+        /**
+         * Verifie si l'image est plus grande que le conteneur et la retaille le cas
+         * echeant
+         */
+        public void verifierEtRetaillerImage() {
+                // si l'image est nulle
+                if (image == null) {
+                        // on ne fait rien
+                        return;
+                }
+                // on prend la taille originale de l'image
+                int originalX = getTailleImage()[0];
+                int originalY = getTailleImage()[1];
+                // on la transforme en float (la division entre entier donne de curieux
+                // résultats)
+                float fOriginalX = (new Float(originalX)).floatValue();
+                float fOriginalY = (new Float(originalY)).floatValue();
+                // et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
+                float rapportTaille = fOriginalX / fOriginalY;
+                // la nouvelle taille est pour le moment égale à l'ancienne
+                int nouvelleTailleX = originalX;
+                int nouvelleTailleY = originalY;
+                // on prend la taille du conteneur
+                int tailleConteneurX = imageConteneur.getWidth();
+                int tailleConteneurY = imageConteneur.getHeight();
+                // si celle-ci est égale à 0 (conteneur mal initialisé)
+                /*
+                 * if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
+                 * essaie de la calculer en fonction de la taille du parent et des
+                 * frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
+                 * this.getWidth() - prev.getOffsetWidth() * 2 ;
+                 *  }
+                 */
+                // si l'image ne rentre pas telle quelle (longueur ou hauteur trop
+                // grande)
+                if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
+                        // si la longueur de l'image est la plus grande des deux
+                        if (originalX > originalY) {
+                                // on prend la longueur comme taille de référence, qu'on met à
+                                // la longueur du conteneur
+                                nouvelleTailleX = tailleConteneurX;
+                                // et on recalcule la hauteur, par rapport à la nouvelle
+                                // longueur, en gardant le format de 'limage
+                                nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
+                                                / rapportTaille);
+                        } else {
+                                // si la hauteur est la plus grande, on fait le même genre
+                                // d'opération en prenant la hauteur comme référence
+                                nouvelleTailleY = tailleConteneurY;
+                                nouvelleTailleX = (int) Math.floor(nouvelleTailleY
+                                                * rapportTaille);
+                        }
+                }
+                // on modifie enfin la taille de l'image pour qu'elle soit affichée
+                getImage().setSize("" + nouvelleTailleX + "px",
+                                "" + nouvelleTailleY + "px");
+        }
+        public void configDragAndDrop()
+        {
+                // on fabrique la nouvelle configuration
+                // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
+                DropTargetConfig dtc = new DropTargetConfig();
+                dtc.setdDdGroup("DragGroupName");
+                //La drop target permet de gérer l'évenement onDrop sur l'élement courant
+                @SuppressWarnings("unused")
+                DropTarget tg = new DropTarget(this, dtc)
+                {
+                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){
+                                // si on reçoit des données provenant d'une grille
+                                if(data instanceof GridDragData)
+                          {
+                                                // on appelle le médiateur
+                                                return iMediateur.lierObsDD(source, e, data,getId()) ;
+                          }
+                                return false ;
+                        }
+                        public String notifyOver(DragSource source, EventObject e, DragData data){
+                            return "x-dd-drop-ok";
+                        }
+                };
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Accesseur au conteneur de l'image
+         *
+         * @return le conteneur de l'image
+         */
+        public Image getImage() {
+                return image;
+        }
+        /**
+         * Acesseurs pour l'identifiant de l'image
+         * @return l'id de l'image
+         */
+        public String getIdImage()
+        {
+                return idImage ;
+        }
+        /**
+         * Accesseur pour le bouton précédent
+         *
+         * @return le bouton précédent
+         */
+        public com.google.gwt.user.client.ui.Button getPrev() {
+                return prev;
+        }
+        /**
+         * Accesseur pour le bouton suivant
+         *
+         * @return le bouton suivant
+         */
+        public com.google.gwt.user.client.ui.Button getSuiv() {
+                return suiv;
+        }
+        /**
+         * Setter pour la taille de l'image
+         *
+         * @param x
+         *            la largeur en pixels
+         * @param y
+         *            la hauteur en pixels
+         */
+        public void setTailleImage(int x, int y) {
+                imageHeight = y;
+                imageWidth = x;
+        }
+        /**
+         * Setteur pour l'identifiant de l'image
+         * @param id le nouvel identifiant
+         */
+        public void setIdImage(String id)
+        {
+                idImage = id ;
+        }
+        /**
+         * renvoie la taille originale de l'image
+         *
+         * @return un tableau de deux entiers contenant la largeur puis la hauteur
+         */
+        public int[] getTailleImage() {
+                int[] taille = { imageHeight, imageWidth };
+                return taille;
+        }
+        /**
+         * Accesseur pour le conteneur de l'image
+         * @return le conteur de l'image
+         */
+        public Panel getImageConteneur() {
+                return imageConteneur;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/BarreOutilsVue.java
 New file
 ,0 → 1,89
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import com.gwtext.client.widgets.Toolbar;
+import com.gwtext.client.widgets.ToolbarMenuButton;
+/**
+ * Barre d'outils contenant le menu de gestion des images (accessible aussi par
+ * un clic droit dans la galerie) et d'autres menus et boutons utiles
+ *
+ * @author aurelien
+ *
+ */
+public class BarreOutilsVue extends Toolbar {
+        /**
+         * Un bouton qui sert à déployer le menu
+         */
+        ToolbarMenuButton images = null;
+        /**
+         * Un bouton qui sert à déployer le menu
+         */
+        ToolbarMenuButton utilisateur = null;
+        /**
+         * Le médiateur associé à la toolbar
+         */
+        ImageMediateur iMediateur = null;
+        /**
+         * Le menu de gestion des images
+         */
+        MenuImageVue imageMenu = null;
+        /**
+         * Le menu de gestion des filtres
+         */
+        MenuFiltreVue filtreMenu = null;
+        /**
+         * Le menu de gestion utilisateur
+         */
+        MenuIdVue idMenu = null;
+        /**
+         * Constructeur sans argument (ne doit pas être utilisé donc privé)
+         */
+        @SuppressWarnings("unused")
+        private BarreOutilsVue() {
+                super();
+        }
+        /**
+         * Constructeur avec paramètres
+         *
+         * @param im
+         *            le médiateur à associer à la vue
+         */
+        public BarreOutilsVue(ImageMediateur im) {
+                super();
+                iMediateur = im;
+                imageMenu = new MenuImageVue(im);
+                filtreMenu = new MenuFiltreVue(im);
+                idMenu = new MenuIdVue(im);
+                images = new ToolbarMenuButton("Fichiers", imageMenu);
+                utilisateur = new ToolbarMenuButton("Utilisateur", idMenu);
+                this.addButton(images);
+                this.addButton(utilisateur);
+        }
+        /**
+         * @return the images
+         */
+        public ToolbarMenuButton getImages() {
+                return images;
+        }
+        /**
+         * @return the iMediateur
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/SelectionFiltreVue.java
 New file
 ,0 → 1,89
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Filtrable;
+import com.google.gwt.user.client.ui.Label;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.form.Checkbox;
+public class SelectionFiltreVue extends Panel implements Filtrable {
+        private ImageMediateur iMediateur = null;
+        private boolean filtreModifie = false;
+        private Checkbox check = null;
+        @SuppressWarnings("unused")
+        private SelectionFiltreVue()
+        {
+                super() ;
+        }
+        public SelectionFiltreVue(ImageMediateur im) {
+                super();
+                iMediateur = im ;
+                Label labelRecherche = new Label(
+                                "Afficher uniquement les images dans le tampon :");
+                add(labelRecherche);
+                setBorder(false);
+                setPaddings(5);
+                /*
+                 * combo = new ComboBox() ; String tout = "toutes les images "; String
+                 * selection = "dans le tampon seulement" ; Object[][] data = new
+                 * Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ;
+                 * data[1][1] = selection ;
+                 *  // creation du store qui les contient FieldDef defIdChoix = new
+                 * IntegerFieldDef("id_choix"); FieldDef defNomChoix = new
+                 * StringFieldDef("nom_choix");
+                 *
+                 * FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new
+                 * RecordDef(defTab) ;
+                 *
+                 * final MemoryProxy dataProxy = new MemoryProxy(data); final
+                 * ArrayReader reader = new ArrayReader(rd);
+                 *
+                 * st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ;
+                 * combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL);
+                 * combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ;
+                 * add(combo) ;
+                 */
+                check = new Checkbox();
+                check.setChecked(false) ;
+                add(check);
+        }
+        public boolean renvoyerEtatFiltre() {
+                return filtreModifie;
+        }
+        public String renvoyerNomFiltre() {
+                return "Filtre par tampon";
+        }
+        public String[] renvoyerValeursAFiltrer() {
+                if (check.getValue()) {
+                        String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() };
+                        return val;
+                }
+                String[] val = { "ci_id_tampon", "" };
+                return val;
+        }
+        public void valider() {
+                filtreModifie = true;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java
 New file
 ,0 → 1,335
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.interfaces.VueListable;
+import org.tela_botanica.client.vues.BarrePaginationObservationVue;
+import com.gwtext.client.core.Ext;
+import com.gwtext.client.core.ExtElement;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.Record;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+import com.gwtext.client.widgets.Component;
+import com.gwtext.client.widgets.event.ContainerListenerAdapter;
+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.RowSelectionModel;
+import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
+/**
+ * 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 {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ObservationMediateur    observationMediateur            = null;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    etatObservation;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    nomSaisiObservation;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    nomRetenuObservation;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    lieuObservation;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    dateObservation;
+        /**
+         * Config de colonne
+         */
+        private ColumnConfig    ordreObservation;
+        /**
+         * Modele de colonnes
+         */
+        private ColumnModel             modeleColonnes;
+        /**
+         * Store qui contient les données à afficher
+         */
+        private Store                   st                              = null;
+        /**
+         * Barre de pagination
+         */
+        private BarrePaginationObservationVue bt = null ;
+        /**
+         * Constructeur sans arguments (privé car ne doit pas être utilisé)
+         */
+        private ListeObservationVue()
+        {
+                super() ;
+        }
+        /**
+         * Constructeur avec argument
+         * @param im le médiateur à associer
+         */
+        public ListeObservationVue(ObservationMediateur obs) {
+                this.observationMediateur = obs;
+                setHeader(true);
+                setTitle("Observations");
+                // on place la barre de pagination
+                bt = new BarrePaginationObservationVue(observationMediateur);
+                this.setBottomToolbar(bt) ;
+                // 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)
+                etatObservation = new ColumnConfig("Transmis", "etat_observation", 50);
+                nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200);
+                nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200);
+                lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200);
+                dateObservation = new ColumnConfig("Date", "date_observation", 70);
+                ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50);
+                // on associe le modèle de colonnes
+                ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation};
+                modeleColonnes = new ColumnModel(cm);
+                this.setColumnModel(modeleColonnes);
+                this.setAutoScroll(true);
+                this.setAutoWidth(true);
+                this.setEnableColumnResize(true);
+            // FIXME: ca ne devrait pas ête obligatoire de fixer la taille
+                this.setSize(800,400);
+                // creation du store
+                FieldDef defEtatObservation = new StringFieldDef("etat_observation");
+                FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
+                FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
+                FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
+                FieldDef defDateObservation = new StringFieldDef("date_observation");
+                FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
+                FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
+                                defLieuObservation, defDateObservation, defOrdreObservation };
+                RecordDef rd = new RecordDef(defTab);
+                st = new Store(rd);
+                // on associe le store
+                this.setStore(st);
+                this.getView().setAutoFill(true);
+                // on crée un masque de chargement qui s'affichera lors des mises à jour
+                this.setLoadMask("Chargement");
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners pour la gestion des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new ContainerListenerAdapter() {
+                        public void onHide(Component component) {
+                        }
+                        public void onRender(Component component) {
+                        }
+                        public void onShow(Component component) {
+                        }
+                });
+/*
+                this.addGridRowListener(new GridRowListener() {
+                        // gestion du clic sur une ligne
+                        public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {
+                                // on notifie le médiateur et on lui passe le nuémro de ligne
+                                getobservationMediateur().clicListeImage(rowIndex);
+                        }
+                        // gestion du clic droit
+                        public void onRowContextMenu(GridPanel grid, int rowIndex,
+                                        EventObject e) {
+                                // on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
+                                e.stopEvent() ;
+                                // on notifie le médiateur en lui passant l'évenement
+                                getobservationMediateur().montrerContextMenu(e);
+                        }
+                        // gestion du double clic
+                        public void onRowDblClick(GridPanel grid, int rowIndex,
+                                        EventObject e) {
+                                // on notifie le médiateur en lui passant le numéro de ligne
+                                getobservationMediateur().doubleClicListeImage(rowIndex);
+                        }
+                });
+        */
+                this.getSelectionModel().addListener(new RowSelectionListenerAdapter() {
+                        // gestion de la sélection
+                        public void onSelectionChange(RowSelectionModel sm) {
+                                // si on a rien de sélectionné
+                                if (sm.getCount() <= 0) {
+                                        // on notifie le médiateur (qui désactive notamment l'accès à certaines infos)
+                //                      getobservationMediateur().aucuneSelection();
+                                } else {
+                                        // sinon on notifie le médiateur
+                        //              getobservationMediateur().selection();
+                                        // et on lui demande de synchroniser la selection avec les autres vues
+                                //      getobservationMediateur().synchroniserSelection("liste");
+                                }
+                        }
+                });
+        }
+        /**
+         * Méthode héritée de l'interface VueListable
+         * Sélectionne les observations  dans la liste suivant les identifiants donnés en paramètres
+         */
+        public String[] getIdSelectionnees() {
+                Record[] selection = this.getSelectionModel().getSelections();
+                int taille = selection.length;
+                String id_selection[] = new String[taille];
+                for (int i = 0; i < selection.length; i++) {
+                        id_selection[i] = selection[i].getAsString("ordre_observation");
+                }
+                return id_selection;
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         * @param nouvelleDonnees les nouvelles données
+         * @param repandreRafraichissement le booleen de notification du rafraichissement
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si on reçoit un store
+                if (nouvelleDonnees instanceof Store) {
+                        // on affecte celui-ci comme gestionnaire de données
+                        st = (Store) nouvelleDonnees;
+                        st.load();
+                        // et on reconfigure et rafraichit la vue
+                        this.reconfigure(st, this.getColumnModel());
+                        demasquerChargement();
+                }
+        }
+        /**
+         * 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 BarrePaginationObservationVue getToolBarVue()
+        {
+                return bt ;
+        }
+        /**
+         * Recherche l'élement actuellement affiché et affiche son message de chargement
+         */
+        public void masquerChargement()
+        {
+                        ExtElement masked = Ext.get(getId()) ;
+                        // FIXME: parfois null sans raison !
+                        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()) ;
+//                       FIXME: parfois null sans raison !
+                        if (masked!=null) {
+                                if(masked.isMasked())
+                                {
+                                        masked.unmask() ;
+                                }
+                        }
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/vues/AutoCompleteAsyncTextBox.java
 New file
 ,0 → 1,360
+/*
+Auto-Completion Textbox for GWT
+Copyright (C) 2006 Oliver Albers http://gwt.components.googlepages.com/
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+package org.tela_botanica.client.vues;
+// TODO : traiter latence (augmenter en fonction rapidit� saisie + texte vide)
+// TODO : traitement espace apres l'espece (%20)
+// TODO : Utiliser Suggestbox et les Associating Data Transfer Objects (DTOs) with Suggestion Objects
+import com.google.gwt.user.client.ui.KeyboardListener;
+import com.google.gwt.user.client.ui.ListBox;
+import com.google.gwt.user.client.ui.PopupPanel;
+import com.google.gwt.user.client.ui.TextBox;
+import com.google.gwt.user.client.ui.Widget;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import java.util.Vector;
+import java.util.HashMap;
+import org.tela_botanica.client.interfaces.FournisseurListe;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+public class AutoCompleteAsyncTextBox extends TextBox implements KeyboardListener {
+// Fournisseur de donnees
+  private FournisseurListe fournisseurDeDonnees=null;
+  private HashMap cache = new HashMap();
+  private boolean searching = false;
+  private Rafraichissable rafraichissable=null;
+  protected PopupPanel choicesPopup = new PopupPanel(true);
+  protected ListBox choices = new ListBox() {
+          public void onBrowserEvent(Event event) {
+                  if (Event.ONCLICK == DOM.eventGetType(event)) {
+                          complete();
+                  }
+          }
+  };
+  protected Vector items = new Vector();
+  protected boolean visible = false;
+  /**
+   * Value linked to current text
+   */
+  protected String currentValue = null;
+  /**
+   * Default Constructor
+   *
+   */
+  public AutoCompleteAsyncTextBox(Rafraichissable r)
+  {
+    super();
+    rafraichissable=r;
+    this.addKeyboardListener(this);
+    choices.sinkEvents(Event.ONCLICK);
+    this.setStyleName("AutoCompleteAsyncTextBox");
+    choicesPopup.add(choices);
+    choicesPopup.addStyleName("AutoCompleteChoices");
+    choices.setStyleName("list");
+  }
+  public void setFournisseurDeDonnees(FournisseurListe fournisseurDeDonnees) {
+          this.fournisseurDeDonnees=fournisseurDeDonnees;
+  }
+  private void doFetchData(String match) {
+          String rematch=match.replaceAll(" ","/");
+          rematch=rematch.replaceAll("%","");
+          if (this.fournisseurDeDonnees!=null && searching==false) {
+                  searching=true;
+                  fournisseurDeDonnees.obtenirListeDonnees(rafraichissable, rematch);
+          }
+  }
+  public void onKeyDown(Widget arg0, char arg1, int arg2) {
+          if(arg1 == KEY_ENTER)
+            {
+              enterKey(arg0, arg1, arg2);
+            }
+            else if(arg1 == KEY_DOWN)
+            {
+              downKey(arg0, arg1, arg2);
+            }
+            else if(arg1 == KEY_UP)
+            {
+              upKey(arg0, arg1, arg2);
+            }
+            else if(arg1 == KEY_ESCAPE)
+            {
+              escapeKey(arg0, arg1, arg2);
+            }
+  }
+  /**
+   * Not used at all (probleme avec ie, qui ne comprend pas les touches meta)
+   */
+  public void onKeyPress(Widget arg0, char arg1, int arg2) {
+  }
+  // The down key was pressed.
+  protected void downKey(Widget arg0, char arg1, int arg2) {
+            int selectedIndex = choices.getSelectedIndex();
+            selectedIndex++;
+            if (selectedIndex >= choices.getItemCount())
+            {
+              selectedIndex = 0;
+            }
+            choices.setSelectedIndex(selectedIndex);
+ }
+  // The up key was pressed.
+  protected void upKey(Widget arg0, char arg1, int arg2) {
+    int selectedIndex = choices.getSelectedIndex();
+    selectedIndex--;
+    if(selectedIndex < 0)
+    {
+      selectedIndex = choices.getItemCount() - 1;
+    }
+    choices.setSelectedIndex(selectedIndex);
+  }
+  // The enter key was pressed.
+  protected void enterKey(Widget arg0, char arg1, int arg2) {
+      if(visible)
+      {
+        complete();
+      }
+      else {
+         // Validation de l'entree : appel asynchrone
+        /*  if (autoCompleteAsyncTextBoxListeners!= null) {
+              autoCompleteAsyncTextBoxListeners.fireTextBoxEnter(this,this.getText(),currentValue);
+          }*/
+          currentValue=null;
+          this.setText("");
+          this.setValue(null);
+      }
+  }
+//The escape key was pressed.
+  protected void escapeKey(Widget arg0, char arg1, int arg2) {
+    choices.clear();
+    items.clear();
+    choicesPopup.hide();
+    visible = false;
+  }
+  // Any other non-special key was pressed.
+  protected void otherKey(Widget arg0, char arg1, int arg2) {
+    // Lancement appel
+    String text = this.getText();
+            if(text.length() > 0)
+            {
+                  currentValue=null;
+                      items.clear();
+                      if (getFromCache(text)!=null) {
+                          items=getFromCache(text);
+                          displayList();
+                      }
+                      else {
+                          this.doFetchData(text);
+                      }
+                 }
+  }
+  public void onKeyUp(Widget arg0, char arg1, int arg2) {
+          switch(arg1) {
+      case KEY_ALT:
+      case KEY_CTRL:
+      case KEY_DOWN:
+      case KEY_END:
+      case KEY_ENTER:
+      case KEY_ESCAPE:
+      case KEY_HOME:
+      case KEY_LEFT:
+      case KEY_PAGEDOWN:
+      case KEY_PAGEUP:
+      case KEY_RIGHT:
+      case KEY_SHIFT:
+      case KEY_TAB:
+      case KEY_UP:
+        break;
+      default:
+        otherKey(arg0, arg1, arg2);
+        break;
+    }
+  }
+  // Display assistant
+    public void displayList() {
+        searching=false;
+            if(this.items.size() > 0)
+            {
+              addToCache(this.getText(),(Vector) items.clone());
+              choices.clear();
+              for(int i = 0; i < items.size(); i++)
+              {
+                choices.addItem(((String [])items.get(i))[0],((String [])items.get(i))[1]);
+              }
+              // if there is only one match and it is what is in the
+              // text field anyways there is no need to show autocompletion
+            //  if(items.size() == 1 && (((String []) items.get(0))[0]).compareTo(this.getText()) == 0)
+             // {
+               // choicesPopup.hide();
+             // } else {
+                choices.setSelectedIndex(0);
+                choices.setVisibleItemCount(items.size());
+                visible = true;
+                choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight());
+                choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight());
+                choicesPopup.setWidth(this.getOffsetWidth() + "px");
+                choices.setWidth(this.getOffsetWidth() + "px");
+                choicesPopup.show();
+            //  }
+            } else {
+              visible = false;
+              choicesPopup.hide();
+            }
+          }
+  /**
+   * A mouseclick in the list of items
+   */
+  public void onChange(Widget arg0) {
+    complete();
+  }
+  public void onClick(Widget arg0) {
+    complete();
+  }
+  // add selected item to textbox
+  protected void complete()
+  {
+    if(choices.getItemCount() > 0)
+    {
+      this.setText(choices.getItemText(choices.getSelectedIndex()));
+      currentValue=choices.getValue(choices.getSelectedIndex());
+ /*     if (autoCompleteAsyncTextBoxListeners!= null) {
+          autoCompleteAsyncTextBoxListeners.fireTextBoxComplete(responseTextHandler,this.getText(),currentValue);
+      }*/
+    }
+    visible=false;
+    items.clear();
+    choices.clear();
+    choicesPopup.hide();
+  }
+  public void addItem(String item, String value) {
+          items.add(new String [] {item, value});
+  }
+  private void addToCache (String query, Vector result)
+  {
+        cache.put(query.toLowerCase(),result);
+  }
+  private Vector getFromCache (String query)
+  {
+        return (Vector) cache.get(query.toLowerCase());
+  }
+public String getValue() {
+        return currentValue;
+}
+public  void setValue(String value) {
+         this.currentValue=value;
+}
+}

 /trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
 New file
 ,0 → 1,239
+/**
+ David Delon david.delon@clapas.net 2007
+ */
+/*
+ * LoginDialog.java  (DialogBox)
+ *
+ * Cas d'utilisation :
+ * Dialogue de validation de l'identification utilisateur
+ *
+ * 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe
+ * 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies
+ * 3 : Le dialogue transmet au systeme local les informations d'identification
+ *              3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4.
+ * 4 : Cloture du dialogue
+ * 5 : Appel du dialogue d'importation
+ */
+package org.tela_botanica.client.vues;
+// TODO : controle de forme sur saisie (regex integree) ...
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import com.google.gwt.user.client.ui.DialogBox;
+import com.google.gwt.user.client.ui.KeyboardListener;
+import com.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 email=null;
+        /**
+         * mot de passe saisi
+         */
+        private TextField motDePasse=null;
+  public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) {
+        carnetEnLigneMediateur=cm;
+    Panel panneauPrincipalDialogue=new Panel();
+    FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
+    panneauFormulaire.setTitle("Connexion");
+    panneauFormulaire.setWidth(350);
+    panneauFormulaire.setLabelWidth(100);
+/*
+ *  E-Mail : Zone_saisie_email
+ *  Mot-de-passe : Zone_saisie_mot_de_passe
+ *  Message d'information
+ *  Bouton_Ok   Bouton_Annuler
+ */
+    /**
+     * On ajoute les differents elements du formulaire
+     */
+    // Email
+    email = new TextField("E-mail", "email", 200);
+    email.setAllowBlank(false);
+    panneauFormulaire.add(email);
+    // Mot de passe
+    motDePasse = new TextField("Mot de passe", "motDePasse", 200);
+    motDePasse.setAllowBlank(false);
+    motDePasse.setPassword(true);
+    panneauFormulaire.add(motDePasse);
+    Button boutonOK = new Button("Ok");
+    panneauFormulaire.addButton(boutonOK);
+    Button boutonAnnuler = new Button("Annuler");
+    panneauFormulaire.addButton(boutonAnnuler);
+    // Click sur bouton de validation
+    boutonOK.addListener(
+    new ButtonListenerAdapter() {
+        public void onClick(Button button, EventObject e) {
+                carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText());
+        }
+    }
+    );
+    // Click sur  bouton d'annulation
+    boutonAnnuler.addListener(
+    new ButtonListenerAdapter() {
+        public void onClick(Button button, EventObject e) {
+                hide();
+        }
+    }
+    );
+ /**
+  * Validation directe depuis un champ de saisie
+  *
+  */
+    // Email
+        // gestion de la touche entrée
+    email.addKeyListener(EventObject.ENTER, new KeyListener() {
+                public void onKey(int key, EventObject e) {
+                        carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText());
+                }
+    });
+    // Mot de passe
+    motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() {
+                public void onKey(int key, EventObject e) {
+                        carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText());
+                }
+    });
+         panneauPrincipalDialogue.add(panneauFormulaire);
+     setWidget(panneauPrincipalDialogue);
+  }
+  /*
+   * On sort sur touche echappement
+   */
+  public boolean onKeyDownPreview(char key, int modifiers) {
+            switch (key) {
+              case KeyboardListener.KEY_ESCAPE:
+                hide();
+                break;
+            }
+            return true;
+  }
+  public void afficherMessageAlerte() {
+          //
+  }
+}
+/* +--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/pageToolBarVue.java
 New file
 ,0 → 1,419
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+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 pageToolBarVue extends Toolbar implements Rafraichissable {
+        /**
+         * Instance du médiateur à qui on notifie les évnènements
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Bouton précédent
+         */
+        private ToolbarButton prevPage = new ToolbarButton();
+        /**
+         * Bouton suivant
+         */
+        private ToolbarButton suivPage = new ToolbarButton();
+        /**
+         * Numéro de la page courante (attention, commence à zéro pour des raisons
+         * pratiques)
+         */
+        private int pageCourante = 0;
+        /**
+         * Nombre de page total
+         */
+        private int pageTotale = 1;
+        /**
+         * Nombre d'élements total
+         */
+        private int nbElement = 0;
+        /**
+         * Nombre d'élément par page
+         */
+        private int taillePage = 0;
+        /**
+         * Texte statique de la toolbar 1
+         */
+        private ToolbarTextItem page = new ToolbarTextItem("Page ");
+        /**
+         * Affichage de la page courante
+         */
+        private TextField champPage = new TextField("" + (pageCourante + 1));
+        /**
+         * Affichage de "sur pageTotale "
+         */
+        private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "
+                        + pageTotale);
+        /**
+         * Texte statique de la toolbar 2
+         */
+        private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ");
+        /**
+         * Combobox permettant de selectionner le nombre d'élements à afficher par
+         * page et donc de changer la variable taillePage
+         */
+        private ComboBox selecteurTaillePage = new ComboBox();
+        /**
+         * Texte statique de la toolbar 3
+         */
+        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
+                        " images par page ");
+        /**
+         * Affiche l'intervalle des éléments contenus dans la page
+         */
+        private ToolbarTextItem intervalleElements = new ToolbarTextItem("Images "
+                        + pageCourante * taillePage + " sur " + nbElement);
+        /**
+         * retourne le mediateur associe à la barre
+         */
+        public ImageMediateur getImediateur() {
+                return iMediateur;
+        }
+        /***************************************************************************
+         * constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private pageToolBarVue() {
+                super();
+        }
+        /**
+         * constructeur avec paramètres
+         *
+         * @param im
+         *            le médiateur à associer à la barre
+         */
+        public pageToolBarVue(ImageMediateur im) {
+                super();
+                iMediateur = im;
+                // 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");
+                // le store contient les valeur possibles pour les tailles de page
+                final Store store = new SimpleStore(new String[] { "nb_page" },
+                                getNbPages());
+                store.load();
+                // 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(store);
+                selecteurTaillePage.setWidth(40);
+                selecteurTaillePage.setEditable(false);
+                addField(selecteurTaillePage);
+                selecteurTaillePage.setValue("50");
+                selecteurTaillePage.setWidth(50);
+                addItem(nbElemParPage);
+                // on remplit l'espace pour que l'intervalle d'élement se place à droite
+                // de la barre
+                addFill();
+                addItem(intervalleElements);
+                addSpacer();
+                // on ajoute les différents listeners
+                ajouterListeners();
+        }
+        /**
+         * ajoute les différents listeners nécessaires au bon fonctionnement des
+         * éléments de la barre de pagination
+         */
+        private void ajouterListeners() {
+                // boutons suivants et précédents
+                prevPage.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                // si la page courante n'est pas la première
+                                if (pageCourante > 0) {
+                                        // on décrémente la page courante de 1
+                                        pageCourante--;
+                                        // on rafraichit l'affichage
+                                        rafraichirNumeroPage();
+                                        // et on notifie le médiateur de l'évenement
+                                        getImediateur().changerNumeroPage(pageCourante);
+                                }
+                        }
+                });
+                suivPage.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                // si la page courante n'est pas la dernière
+                                if (pageCourante < pageTotale - 1) {
+                                        // on incrémente la page courante de 1
+                                        pageCourante++;
+                                        // on rafraichit l'affichage
+                                        rafraichirNumeroPage();
+                                        // et on notifie le médiateur de l'évenement
+                                        getImediateur().changerNumeroPage(pageCourante);
+                                }
+                        }
+                });
+                champPage.addListener(new TextFieldListenerAdapter() {
+                        public void onSpecialKey(Field field, EventObject e) {
+                                // on teste si la touche entrée a été pressée
+                                if (e.getKey() == EventObject.ENTER) {
+                                        int nouvellePage = pageCourante;
+                                        // on teste avec parseInt si la valeur entrée est un entier
+                                        try {
+                                                nouvellePage = Integer
+                                                                .parseInt(champPage.getRawValue());
+                                        }
+                                        // si ce n'est pas le cas alors on remet le numéro de page
+                                        // correct
+                                        catch (NumberFormatException nfe) {
+                                                rafraichirNumeroPage();
+                                                champPage.focus(true);
+                                                return;
+                                        }
+                                        // si la conversion reussit on verifie s'il est nécessaire
+                                        // de changer de page
+                                        // et si la nouvelle est comprise dans l'intervalle des
+                                        // pages existantes (0..pageTotale)
+                                        if (nouvellePage != pageCourante + 1 && nouvellePage > 0
+                                                        && nouvellePage <= pageTotale) {
+                                                // le cas échéant, on charge la nouvelle page et on
+                                                // notifie le médiateur
+                                                changerPageCourante(nouvellePage - 1);
+                                                getImediateur().changerNumeroPage(pageCourante);
+                                        } else {
+                                                // sinon on reaffiche l'ancien numero de page sans rien
+                                                // changer
+                                                rafraichirNumeroPage();
+                                                champPage.focus(true);
+                                        }
+                                }
+                        }
+                        public void onFocus(Field field) {
+                                champPage.focus(true);
+                        }
+                });
+                // pour éviter de se compliquer la vie, on filtre tous les charactères
+                // non numériques
+                champPage.addKeyPressListener(new EventCallback() {
+                        public void execute(EventObject e) {
+                                // si c'est un numerique
+                                if (Character.isDigit((char) e.getCharCode())) {
+                                        // on laisse passer
+                                        return;
+                                }
+                                // si c'est la touche entrée ou backspace (valider ou effacer)
+                                if (e.getKey() == EventObject.ENTER
+                                                || e.getKey() == EventObject.BACKSPACE) {
+                                        // on laisse passer
+                                        return;
+                                } else {
+                                        // sinon on remet le numero de page correct et on annule
+                                        // l'évenement
+                                        rafraichirNumeroPage();
+                                        e.stopEvent();
+                                }
+                        }
+                });
+                // listener pour la selection dans la combobox
+                selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
+                        public void onSelect(ComboBox comboBox, Record record, int index) {
+                                String nouvelleTaillePageString = comboBox.getStore()
+                                                .getRecordAt(index).getAsString("nb_page");
+                                int nouvelleTaillePage = Integer
+                                                .parseInt(nouvelleTaillePageString);
+                                // si la taille de page est différente de l'ancienne
+                                if (nouvelleTaillePage != taillePage) {
+                                        // on la change
+                                        changerTaillePage(nouvelleTaillePage);
+                                }
+                                // et on met la valeur à jour dans la combobox
+                                comboBox.setValue(nouvelleTaillePageString);
+                        }
+                });
+        }
+        /**
+         * Met à jour les affichage sur les numéros de pages et d'intervalle
+         * d'éléments à partir des variables de classes
+         */
+        public void rafraichirNumeroPage() {
+                surTotalPage.setText(" sur " + pageTotale);
+                if (nbElement == 0) {
+                        champPage.setValue("" + (0));
+                        // on met simplement à jour l'intervalle qui contient toujours le
+                        // même nombre d'éléments
+                        intervalleElements.setText("Images 0 - 0 sur 0");
+                } else {
+                        champPage.setValue("" + (pageCourante + 1));
+                        // si la page n'est pas la dernière
+                        if (pageCourante + 1 != pageTotale) {
+                                // sauf pour la dernière page qui contient souvent moins
+                                // d'élements que le nombre d'élements par page
+                                intervalleElements.setText("Images " + pageCourante
+                                                * taillePage + " - " + (pageCourante + 1) * taillePage
+                                                + " sur " + nbElement);
+                        } else {
+                                // on met simplement à jour l'intervalle qui contient toujours
+                                // le même nombre d'éléments
+                                intervalleElements.setText("Images " + pageCourante
+                                                * taillePage + " - " + nbElement + " sur " + nbElement);
+                        }
+                }
+        }
+        /**
+         * Met à jour la page en cours
+         *
+         * @param nouvellePageCourante
+         *            la nouvelle page en cours
+         */
+        public void changerPageCourante(int nouvellePageCourante) {
+                pageCourante = nouvellePageCourante;
+        }
+        /**
+         * Methode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                // si on reçoit un tableau de int
+                if (nouvelleDonnees instanceof int[]) {
+                        int[] page = (int[]) nouvelleDonnees;
+                        // le premier élement est le nombre de pages totales
+                        pageTotale = page[0];
+                        // le second la page en cours
+                        pageCourante = page[1];
+                        // le troisième la taille de la page
+                        taillePage = page[2];
+                        // et le dernier le nombre total d'éléments
+                        nbElement = page[3];
+                        // si la page courante dépasse la page totale (cas normalement
+                        // improbable car géré en amont)
+                        // on met le numéro de page à la page courante -1 (car la page
+                        // courante est comptée à partir
+                        // de zéro)
+                        if (pageCourante >= pageTotale && pageCourante != 0) {
+                                pageCourante = pageTotale - 1;
+                                // le cas échéant on en notifie le médiateur
+                                getImediateur().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 tableau de string qui contient les différentes
+         *         taille de pages
+         */
+        public String[][] getNbPages() {
+                String[][] pages = { { "200" }, { "100" }, { "50" }, { "20" }, { "10" } };
+                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) {
+                getImediateur().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);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/LocationAssistantVue.java
 New file
 ,0 → 1,107
+package org.tela_botanica.client.vues;
+import java.util.Iterator;
+import com.google.gwt.user.client.ui.AbsolutePanel;
+import com.google.gwt.user.client.ui.Composite;
+import com.google.gwt.user.client.ui.HorizontalPanel;
+import com.gwtext.client.widgets.form.TextField;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.ListeReferentielCommune;
+import org.tela_botanica.client.modeles.ReferentielCommune;
+import org.tela_botanica.client.observation.ObservationMediateur;
+/**
+ * Affiche une liste de localite qui peuvent etre selectionnees, retourne la valeur de la localite selectionne et une code associe
+ * (gettext et getvalue pour le code associe)
+ * Utilise un assistant de saisie asynchrone.
+ */
+public class LocationAssistantVue extends Composite implements Rafraichissable  {
+  private AutoCompleteAsyncTextBox autoCompletebox = null;
+  //private HorizontalPanel panel = new HorizontalPanel();
+  private AbsolutePanel panel = new AbsolutePanel();
+  private TextField textfield = new TextField("Commune","commune",275);
+  private ObservationMediateur observationMediateur = null;
+  public LocationAssistantVue(ObservationMediateur obs) {
+        observationMediateur=obs;
+        autoCompletebox = new AutoCompleteAsyncTextBox(this);
+//      autoCompletebox.setFocus(true); FIXME : ne fonctionne pas
+ //   autoCompletebox.setFournisseurDeDonnees(observationMediateur.obtenirFournisseurReferentielCommune());
+    panel.add(textfield);
+        panel.add(autoCompletebox,0,0);
+        //autoCompletebox.setWidth("100%");
+    initWidget(panel);
+  }
+public String getText() {
+        return autoCompletebox.getText();
+}
+public void setText(String str) {
+        autoCompletebox.setText(str);
+}
+public void setValue(String value) {
+        autoCompletebox.setValue(value);
+}
+public String getValue() {
+        return autoCompletebox.getValue();
+}
+public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
+//               si l'on a reçu une liste d'observation
+                if(nouvelleDonnees instanceof ListeReferentielCommune) {
+                                ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ;
+                                // on la parse et on récupère les informations quiç nous interessent
+                                for (Iterator it = data.keySet().iterator(); it.hasNext();)
+                                {
+                                        ReferentielCommune com=(ReferentielCommune) data.get(it.next());
+                                        autoCompletebox.addItem(com.getCommune(),com.getDepartement());
+                                }
+                                autoCompletebox.displayList();
+                }
+}
+}

 /trunk/src/org/tela_botanica/client/vues/PanneauFiltresVues.java
 New file
 ,0 → 1,145
+package org.tela_botanica.client.vues;
+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.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.layout.VerticalLayout;
+/**
+ * Panneau contenant les filtres qu'on peut appliquer aux images
+ *
+ * @author aurelien
+ *
+ */
+public class PanneauFiltresVues extends Panel {
+        /**
+         * Le médiateur associé
+         */
+        @SuppressWarnings("unused")
+        private ImageMediateur iMediateur = null;
+        /**
+         * L'arbre pour la recherche par mots clés
+         */
+        private ArbreMotsClesFiltreVue motsClesFiltres = null;
+        /**
+         * La barre de recherche par commentaires
+         */
+        private BarreRechercheFiltreVue commFiltresVues = null;
+        /**
+         * Recherche par date
+         */
+        private DateFiltreVue dateFiltreVues = null;
+        /**
+         * Recherche par contenu du tampon
+         */
+        private SelectionFiltreVue selectionFiltreVue = null;
+        /**
+         * Bouton de validation
+         */
+        private Button valider = null;
+        /**
+         * Construcuteur sans argument (privé car on ne doit pas l'utiliser)
+         */
+        @SuppressWarnings("unused")
+        private PanneauFiltresVues() {
+                super();
+        }
+        /**
+         * Constructeur avec arguments
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public PanneauFiltresVues(ImageMediateur im) {
+                super("Rechercher des images");
+                iMediateur = im;
+                this.setCollapsible(true);
+                setLayout(new VerticalLayout());
+                commFiltresVues = new BarreRechercheFiltreVue(im);
+                add(commFiltresVues);
+                dateFiltreVues = new DateFiltreVue(im);
+                add(dateFiltreVues);
+                selectionFiltreVue = new SelectionFiltreVue(im);
+                add(selectionFiltreVue);
+                motsClesFiltres = new ArbreMotsClesFiltreVue(im);
+                add(motsClesFiltres);
+                Panel panelValidation = new Panel();
+                valider = new Button("Rechercher");
+                panelValidation.add(valider);
+                panelValidation.setBorder(false);
+                add(panelValidation);
+                valider.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage());
+                        }
+                });
+        }
+        /**
+         * Accesseur pour le filtre des mots clés
+         *
+         * @return le filtre des mots clés
+         */
+        public ArbreMotsClesFiltreVue getMotsClesFiltre() {
+                return motsClesFiltres;
+        }
+        /**
+         * Accesseur pour le filtre par commentaire
+         *
+         * @return le filtre des commentaires
+         */
+        public BarreRechercheFiltreVue getBarreRecherche() {
+                return commFiltresVues;
+        }
+        /**
+         * Renvoie un booléen indiquant si un des filtres a été modifié
+         *
+         * @return true sur un des filtres est modifié, false sinon
+         */
+        public boolean renvoyerEtatFiltre() {
+                return (motsClesFiltres.renvoyerEtatFiltre()
+                                || commFiltresVues.renvoyerEtatFiltre()
+                                || dateFiltreVues.renvoyerEtatFiltre()
+                                || selectionFiltreVue.renvoyerEtatFiltre());
+        }
+        /**
+         * Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre",
+         * "valeur"
+         *
+         * @return un tableau contenant les noms et les valeurs à filtrer
+         */
+        public String[][] renvoyerValeursAFiltrer() {
+                String[][] filtres = { motsClesFiltres.renvoyerValeursAFiltrer(),
+                                commFiltresVues.renvoyerValeursAFiltrer(),
+                                dateFiltreVues.renvoyerValeursAFiltrer(),
+                                selectionFiltreVue.renvoyerValeursAFiltrer() };
+                return filtres;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
 New file
 ,0 → 1,482
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.Window;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.data.Node;
+import com.gwtext.client.data.NodeTraversalCallback;
+import com.gwtext.client.data.Tree;
+import com.gwtext.client.widgets.Button;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.form.TextField;
+import com.gwtext.client.widgets.layout.VerticalLayout;
+import com.gwtext.client.widgets.tree.TreeEditor;
+import com.gwtext.client.widgets.tree.TreeNode;
+import com.gwtext.client.widgets.tree.TreePanel;
+import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
+/**
+ * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
+ * clés cochables et réorganisables à volonté
+ *
+ * @author aurelien
+ *
+ */
+public class ArbreMotsClesVue extends Panel implements Rafraichissable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Le treepanel qui affiche l'arbre
+         */
+        private TreePanel arbreMotsCles = null;
+        /**
+         * L'éditeur qui permet de modifier les mots clés dans l'arbre
+         */
+        private TreeEditor te = null;
+        /**
+         * Le textfield associé à l'éditeur
+         */
+        private TextField tfEdit = null;
+        /**
+         * Bouton de validation
+         */
+        private Button valider = null;
+        /**
+         * Une string permettant connaitre les mots clés cochés en cours séparés par
+         * des virgules
+         */
+        private String motsClesEnCours = "";
+        /**
+         * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
+         * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
+         * du conteneur n'ai été effectué)
+         */
+        private String[] motsClesEnAttente;
+        /**
+         * 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 estInstancie = false;
+        /**
+         * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
+         */
+        private boolean motsCleInitialises;
+        /**
+         * Constructeur sans paramètre (privé car interdit d'utilisation)
+         */
+        @SuppressWarnings("unused")
+        private ArbreMotsClesVue() {
+                super();
+        }
+        /**
+         * Constructeur avec paramètre
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public ArbreMotsClesVue(ImageMediateur im) {
+                // on crée le panel
+                super("Mots clés");
+                this.setLayout(new VerticalLayout());
+                iMediateur = im;
+                // on crée le conteneur de l'arbre
+                arbreMotsCles = new TreePanel();
+                // on permet le drag and drop dans l'arbre
+                arbreMotsCles.setEnableDD(true);
+                arbreMotsCles.setId("x-view-tree-keyword");
+                // on crée une racine pour l'arbre
+                TreeNode root = new TreeNode("Tags");
+                root.setId("racine");
+                String[] usObject = { "Mots clés", "racine" };
+                root.setUserObject(usObject);
+                arbreMotsCles.setRootNode(root);
+                arbreMotsCles.setRootVisible(false);
+                arbreMotsCles.setBorder(false);
+                arbreMotsCles.setWidth(500);
+                // on crée l'éditeur pour l'arbre
+                tfEdit = new TextField();
+                tfEdit.setAutoWidth(true);
+                te = new TreeEditor(arbreMotsCles, tfEdit);
+                valider = new Button("Appliquer");
+                arbreMotsCles.add(te);
+                // on met en forme le layout
+                this.add(arbreMotsCles);
+                this.add(valider);
+                this.setBorder(false);
+                this.setCollapsible(true);
+                this.setTitleCollapse(true);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Acesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        private ImageMediateur GetIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Acesseur pour l'arbre des mots clés
+         *
+         * @return le panel contenant l'arbre
+         */
+        public TreePanel getArbreMotsCles() {
+                return arbreMotsCles;
+        }
+        /**
+         * Accesseur pour l'éditeur
+         *
+         * @return l'éditeur associé à l'arbre
+         */
+        public TreeEditor getTe() {
+                return te;
+        }
+        /**
+         * Acesseur pour le TextField associé à l'éditeur
+         *
+         * @return le champ texte associé à l'éditeur
+         */
+        public TextField getTfEdit() {
+                return tfEdit;
+        }
+        /**
+         * Ajoute les listeners nécessaires pour la gestion des évènements
+         */
+        private void ajouterListeners() {
+                arbreMotsCles.addListener(new TreePanelListenerAdapter() {
+                        // gestion du clic sur un noeud
+                        public void onClick(TreeNode node, EventObject e) {
+                                e.stopEvent();
+                                gererClicNoeud(node);
+                        }
+                        // gestion du clic droit sur un noeud
+                        public void onContextMenu(TreeNode node, EventObject e) {
+                                e.stopEvent();
+                                GetIMediateur().montrerContextMenuArbre(node, e, getTe());
+                        }
+                        // gestion du double clic sur un noeud
+                        public void onDblClick(TreeNode node, EventObject e) {
+                                modifNoeud = true;
+                                if (!node.getId().equals("racine")) {
+                                        te.startEdit(node);
+                                }
+                        }
+                        // gestion de la modification du texte d'un noeud
+                        public void onTextChange(TreeNode node, String text, String oldText) {
+                                // on récupère les informations associées au noeud
+                                TreeNode nd = node;
+                                String[] usObject = new String[2];
+                                usObject[0] = text;
+                                usObject[1] = ((String[]) nd.getUserObject())[1];
+                                nd.setUserObject(usObject);
+                                // si c'est un nouveau noeud
+                                if (ajoutNoeud) {
+                                        // on notifie le médiateur de l'ajout et on lui passe
+                                        // l'arbre
+                                        GetIMediateur().ajouterMotCleDansArbre(nd,
+                                                        getArbreMotsCles().getTree());
+                                        // et considière l'ajout achevé
+                                        ajoutNoeud = false;
+                                }
+                                // si c'est noeud déjà existant
+                                else {
+                                        if (modifNoeud) {
+                                                // on notifie le médiateur de la modification et on lui
+                                                // passe l'arbre
+                                                GetIMediateur().modifierMotCleDansArbre(nd,
+                                                                getArbreMotsCles().getTree());
+                                                // et on considère la modification achevée
+                                                modifNoeud = false;
+                                        }
+                                }
+                        }
+                        // gestion du déplacement d'un noeud
+                        public void onMoveNode(Tree tree, TreeNode node,
+                                        TreeNode oldParent, TreeNode newParent, int index) {
+                                // on notifie le médiateur et on lui passe l'arbre
+                                GetIMediateur().deplacerMotCleDansArbre(node,
+                                                getArbreMotsCles().getTree());
+                        }
+                });
+                // gestion de la validation
+                valider.addListener(new ButtonListenerAdapter() {
+                        // lors du clic
+                        public void onClick(Button button, EventObject e) {
+                                // on vide les mots clés en cours
+                                motsClesEnCours = "";
+                                // pour chaque noeud à partir de la racine
+                                getArbreMotsCles().getRootNode().cascade(
+                                                new NodeTraversalCallback() {
+                                                        // on éxécute une fonction
+                                                        public boolean execute(Node node) {
+                                                                // on récupère le mot clé associé au noeud et
+                                                                // ses infos
+                                                                TreeNode tn = getArbreMotsCles().getNodeById(
+                                                                                node.getId());
+                                                                String[] usObject = (String[]) tn
+                                                                                .getUserObject();
+                                                                GetIMediateur().mettreAjourMotsClesId(
+                                                                                usObject[0], usObject[1]);
+                                                                if (tn.getUI().isChecked()) {
+                                                                        // et les concatène à la string des mots
+                                                                        // clés en cours
+                                                                        motsClesEnCours += usObject[1] + ",";
+                                                                }
+                                                                return true;
+                                                        }
+                                                });
+                                // enfin on notifie le médiateur et on lui passe l'arbre et la
+                                // liste des mots clés ainsi obtenue
+                                GetIMediateur().mettreAjourMotsCles(motsClesEnCours,
+                                                arbreMotsCles.getTree());
+                        }
+                });
+        }
+        /**
+         * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
+         */
+        public void obtenirArbreMotsCles() {
+                GetIMediateur().obtenirArbreMotsCles(this);
+        }
+        /**
+         * Supprime un noeud de l'arbre
+         *
+         * @param n
+         *            le noeud à supprimer
+         */
+        public void supprimerNoeud(TreeNode n) {
+                // si ça n'est pas la racine (qu'on ne peut pas supprimer)
+                if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
+                        // on détache le noeud et on le détruit
+                        n.getParentNode().removeChild(n);
+                        n.destroy();
+                        // puis on en notifie le médiateur en lui passant le noeud supprimé
+                        // et l'arbre
+                        GetIMediateur()
+                                        .supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
+                } else {
+                        // si l'utilisateur tente de supprimer la racine, on l'avertit de
+                        // son erreur
+                        Window.alert("Impossible de supprimer la racine de l'arbre");
+                }
+        }
+        /**
+         * Ajoute un noeud dans l'arbre au parent donné
+         *
+         * @param parent
+         *            le futur parent du noeud à ajouter
+         */
+        public void ajouterNoeud(TreeNode parent) {
+                // on met l'ajout du noeud à vrai
+                ajoutNoeud = true;
+                // on crée un nouveau noeud vide
+                TreeNode nd = new TreeNode("");
+                nd.setCls("x-view-treenode-keyword");
+                nd.setChecked(true);
+                // on associe un objet au noeud qui contient des infos
+                String[] usObject = new String[2];
+                // l'objet contient le nom du noeud
+                usObject[0] = "";
+                usObject[1] = genererIdMotCle(nd);
+                nd.setId(usObject[1]);
+                nd.setUserObject(usObject);
+                // l'identifiant d'un noeud c'est son hashcode
+                // l'objet associé au noeud contient aussi son identifiant
+                // on le concatène au parent et on étend ses enfants
+                parent.appendChild(nd);
+                parent.expand();
+                // enfin on place le curseur et on fait apparaitre le champ d'édition
+                // pour que l'utilisateur nomme son mot clé
+                te.startEdit(nd);
+        }
+        /**
+         * Coche le noeud s'il est décoché, le décoche sinon
+         *
+         * @param node
+         */
+        public void gererClicNoeud(TreeNode node) {
+                if (node.getUI().isChecked()) {
+                        node.getUI().toggleCheck(false);
+                } else {
+                        node.getUI().toggleCheck(true);
+                }
+        }
+        /**
+         * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
+         * clés à cocher
+         *
+         * @param motsClesIds
+         *            un tableau contenant les identifiants des mots clés à cocher
+         */
+        public void cocherMotsCles(final String[] motsClesIds) {
+                if (getArbreMotsCles() != null
+                                && getArbreMotsCles().getRootNode() != null) {
+                        // à partir de la racine
+                        getArbreMotsCles().getRootNode().cascade(
+                                        new NodeTraversalCallback() {
+                                                // pour chaque noeud
+                                                public boolean execute(Node node) {
+                                                        // 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;
+                                                                }
+                                                                getArbreMotsCles().getNodeById(node.getId())
+                                                                                .getUI().toggleCheck(false);
+                                                        }
+                                                        // et on passe au suivant
+                                                        return true;
+                                                }
+                                        });
+                }
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         *
+         * @param nouvelleDonnees
+         *            les nouvelles données pour l'objet
+         * @param repandreRafraichissement
+         *            booleen qui dit si on doit répandre l'évenement
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si on a reçu un arbre
+                if (nouvelleDonnees instanceof Tree) {
+                        Tree nouvelArbre = (Tree) nouvelleDonnees;
+                        if (nouvelArbre.getRootNode().getChildNodes().length <= 0) {
+                                // on crée une racine pour l'arbre
+                                TreeNode root = new TreeNode("Tags");
+                                root.setId("racine");
+                                String[] usObject = { "Mots clés", "racine" };
+                                root.setUserObject(usObject);
+                        }
+                        // 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();
+                        }
+                        getArbreMotsCles().getRootNode().appendChild(
+                                        nouvelArbre.getRootNode());
+                        // si l'arbre n'était pas encore considéré comme instancié
+                        if (!estInstancie) {
+                                // on signale que oui
+                                estInstancie = 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;
+                        }
+                }
+                // Si on reçoit un tableau de String (cas ou l'on séléectionne une
+                // nouvelle image)
+                if (nouvelleDonnees instanceof String[]) {
+                        // et que l'arbre est instancié
+                        if (estInstancie && nouvelleDonnees != null) {
+                                // le tableau de String contient les id des mots clés associés à
+                                // l'image
+                                // on coche les mots clés contenu dans le tableau
+                                String[] motsClesIds = (String[]) nouvelleDonnees;
+                                cocherMotsCles(motsClesIds);
+                        }
+                        // si l'arbre n'est pas encore instancié on met les mots clés en
+                        // attente
+                        else {
+                                motsClesEnAttente = (String[]) nouvelleDonnees;
+                        }
+                }
+        }
+        private String genererIdMotCle(TreeNode nd) {
+                return "" + (nd.hashCode() + (Math.random() * 10000));
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/MenuImageVue.java
 New file
 ,0 → 1,139
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.widgets.menu.BaseItem;
+import com.gwtext.client.widgets.menu.Item;
+import com.gwtext.client.widgets.menu.Menu;
+import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
+/**
+ * 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 Item 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;
+        /**
+         * 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;
+                // on construit le menu
+                uploaderImage = new Item("Uploader des images");
+                supprimerImage = new Item("Supprimer les images selectionnées");
+                ajouterImageSelection = new Item(
+                                "Ajouter les images sélectionnées au tampon");
+                viderSelection = new Item("Vider le tampon");
+                afficherSelection = new Item("Afficher le tampon");
+                addItem(uploaderImage);
+                addItem(supprimerImage);
+                addSeparator() ;
+                addItem(ajouterImageSelection);
+                addItem(viderSelection);
+                addItem(afficherSelection);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners pour la gestions des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new MenuListenerAdapter() {
+                        // gestion du clic sur un item
+                        public void onItemClick(BaseItem item, EventObject e) {
+                                // si c'est l'upload
+                                if (item.equals(uploaderImage)) {
+                                        // on notifie le médiateur
+                                        getIMediateur().uploaderImages();
+                                }
+                                // 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 la liaison
+                                if (item.equals(afficherSelection)) {
+                                        getIMediateur().afficherIdSelectionImages();
+                                }
+                                // 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/client/vues/BarreNotationVue.java
 New file
 ,0 → 1,223
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.ui.ClickListener;
+import com.google.gwt.user.client.ui.Image;
+import com.google.gwt.user.client.ui.MouseListenerAdapter;
+import com.google.gwt.user.client.ui.Widget;
+import com.gwtext.client.widgets.Panel;
+/**
+ * Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique,
+ * utilisant Ajax (et pas CSS)
+ *
+ * @author aurelien
+ *
+ */
+public class BarreNotationVue extends Panel implements Rafraichissable {
+        /**
+         * Le médiateur associé
+         */
+        @SuppressWarnings("unused")
+        private ImageMediateur iMediateur = null;
+        /**
+         * La note actuellement affichée
+         */
+        private int noteEnCours = 0;
+        /**
+         * La note maximum
+         */
+        private int noteMax = 0;
+        /**
+         * Booléen indiquant si une note est affectée à la barre en ce moment
+         */
+        private boolean estNote = false;
+        /**
+         * Tablmeau d'images contenant les étoiles affichées
+         */
+        private Image[] etoiles = null;
+        /**
+         * Constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private BarreNotationVue() {
+                super();
+        }
+        /**
+         * Constructeur avec arguments
+         *
+         * @param im
+         *            le médiateur à associer à la vue
+         * @param noteMax
+         *            la note maximale
+         */
+        public BarreNotationVue(ImageMediateur im, int noteMax) {
+                iMediateur = im;
+                setNoteMax(noteMax);
+                this.setSize(200, 100);
+                this.setBodyBorder(false);
+                this.setBorder(false);
+                this.setCls("x-view-notation");
+                ajouterListeners();
+        }
+        public void ajouterListeners() {
+                for (int i = 0; i < etoiles.length; i++) {
+                        etoiles[i].addMouseListener(new MouseListenerAdapter() {
+                                // si la souris passe sur la barre
+                                public void onMouseEnter(Widget sender) {
+                                        Image enCours = (Image) sender;
+                                        // on met en surbrillance toutes les étoiles allant de la
+                                        // première jusqu'à
+                                        // celle sous le curseur
+                                        for (int i = 0; etoiles[i] != enCours; i++) {
+                                                etoiles[i].setUrl("note-hover.gif");
+                                        }
+                                        enCours.setUrl("note-hover.gif");
+                                }
+                                // si la souris sort de la barre
+                                public void onMouseLeave(Widget sender) {
+                                        // on affiche la véritable note
+                                        afficherNote();
+                                }
+                        });
+                        etoiles[i].addClickListener(new ClickListener() {
+                                // si on clique sur une étoiles
+                                public void onClick(Widget sender) {
+                                        int i = 0;
+                                        // on récupère le numéro de l'étoile sur laquelle on a
+                                        // cliqué
+                                        while (etoiles[i] != (Image) sender) {
+                                                i++;
+                                        }
+                                        // et on affecte la note
+                                        noter(i);
+                                }
+                        });
+                }
+        }
+        /**
+         * Fonction héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                // si on recoit un tableau de string
+                if (nouvelleDonnees instanceof String[]) {
+                        // on récupère le premier élément (un entier, qui contient la note)
+                        String[] note = (String[]) nouvelleDonnees;
+                        int noteInt = Integer.parseInt(note[0]);
+                        // si l'entier est une note valide
+                        if (noteInt != -1 && noteInt >= 0) {
+                                noter(noteInt);
+                        }
+                        // sinon si l'entier vaut -1
+                        else {
+                                // alors on note avec 0
+                                // et on met le booleen de notation a false (qui signifie que
+                                // l'image n'est pas encore notée)
+                                estNote = false;
+                                noteEnCours = 0;
+                                // et demande l'affichage
+                                afficherNote();
+                        }
+                }
+        }
+        /**
+         * Affecte une note à la barre et rafraichit l'affichage
+         *
+         * @param note
+         *            la nouvelle note
+         */
+        public void noter(int note) {
+                // on affecte la note
+                noteEnCours = note;
+                // on met le boolean de notation à true (l'image est notée)
+                estNote = true;
+                // et on demande l'affichage
+                afficherNote();
+        }
+        /**
+         * Setteur pour la note maximale
+         *
+         * @param nMax
+         *            la nouvelle note maximale
+         */
+        public void setNoteMax(int nMax) {
+                // on affecte la note
+                noteMax = nMax;
+                // on prépare le tableau d'image
+                etoiles = new Image[noteMax];
+                // qu'on remplit par defaut avec des images d'étoiles vides
+                for (int i = 0; i < noteMax; i++) {
+                        etoiles[i] = new Image("etoile_vide.jpg");
+                        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;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/MiniListeObservationVue.java
 New file
 ,0 → 1,160
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+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.event.ContainerListenerAdapter;
+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.core.EventObject;
+import com.gwtext.client.dd.DragData;
+/**
+ * Fausse liste d'observation pour tester le drag n' drop et l'insertion
+ * Est vouée à devenir une véritable liste avec de vraie données
+ * @author aurelien
+ *
+ */
+public class MiniListeObservationVue extends GridPanel implements Rafraichissable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null ;
+        /**
+         * Booléen d'instanciation
+         */
+        private boolean estInstancie = false ;
+        /**
+         * Le modèle de colonnes
+         */
+        private ColumnModel colModel = null ;
+        /**
+         * Constructeur avec arguments
+         * @param im le médiateur à associer à la vue
+         */
+        public MiniListeObservationVue(ImageMediateur im)
+        {
+                iMediateur = im ;
+                this.setId("x-view-mini-obs") ;
+                // on crée un store simple contenant un petit set de données et deux colonnes
+                final Store store = new SimpleStore(new String[]{"id_obs","plante"}, getObs());
+                ColumnConfig[] columns = {
+                new ColumnConfig("Numero", "id_obs", 65, true),
+                new ColumnConfig("Taxon", "plante", 150, true) } ;
+        ColumnModel columnModel = new ColumnModel(columns);
+        colModel = columnModel ;
+        setTitle("Observations");
+        // on associe le modèle de colonnes
+        setColumnModel(columnModel);
+        setHeight(390);
+        setWidth(200);
+        // on autorise le drag 'n drop pour un certain groupe
+                this.setEnableDragDrop(true);
+                this.setDdGroup("DragGroupName");
+        store.load();
+                setStore(store) ;
+                // on configure le drag 'n drop
+                configDragAndDrop() ;
+        }
+        /**
+         * Configure le drag 'n drop pour la liste
+         */
+        private void configDragAndDrop()
+        {
+                // on choisit le texte qui sera affiché lors d'un drag 'n drop
+                setDragDropText("Faites glisser la selection d'observations sur une image pour les lier") ;
+                //On active le drag 'n drop
+                this.setEnableDragDrop(true);
+                // on fabrique la nouvelle configuration
+                // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
+                this.setDdGroup("DragGroupName");
+                DropTargetConfig dtc = new DropTargetConfig();
+                dtc.setdDdGroup("DragGroupName");
+                //La drop target permet de gérer l'évenement onDrop sur l'élement courant
+                @SuppressWarnings("unused")
+                DropTarget tg = new DropTarget(this, dtc)
+                {
+                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){
+                                // si on reçoit des données provenant d'une grille
+                                if(data instanceof GridDragData)
+                          {
+                                        // on la convertit
+                                        GridDragData gdd = (GridDragData)data ;
+                                        // et on vérifie que les données ne viennent pas de l'élément courant
+                                        if(gdd.getGrid().getId().equals("x-view-mini-obs"))
+                                        {
+                                                return false ;
+                                        }
+                                        else
+                                        {
+                                                // on appelle le médiateur
+                                                return iMediateur.lierImagesDD(source, e, data) ;
+                                        }
+                          }
+                                return false ;
+                        }
+                        public String notifyOver(DragSource source, EventObject e, DragData data){
+                            return "x-dd-drop-ok";
+                        }
+                };
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                // TODO Auto-generated method stub
+        }
+        /**
+         * Renvoie le faux set de données pour le store
+         * @return un tableau à deux colonnes int - String
+         */
+        private Object[][] getObs() {
+                 return new Object[][]{
+                                 new Object[]{"1","Plantum bizarrum"},
+                                 new Object[]{"2","Feuillum etrangum"},
+                                 new Object[]{"3","Spirus cotapilis"},
+                                 new Object[]{"4","Birita raborum"},
+                                 new Object[]{"5","Spacea sinea"},
+                                 new Object[]{"6","Spacea subtea"},
+                                 new Object[]{"7","Buissnum petitum"},
+                                 new Object[]{"8","Acer monspessulanum"},
+                                 new Object[]{"9","Geranium prouticorum"},
+                                 new Object[]{"10","Rosae epania"},
+                                 new Object[]{"11","Rosea rougea"},
+                                 new Object[]{"12","Liciea rosa"},
+                                 new Object[]{"13","Liciea bella"}
+                 } ;
+         }
+}

 /trunk/src/org/tela_botanica/client/vues/PanneauMetadonneesVue.java
 New file
 ,0 → 1,368
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.ui.Label;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.core.NameValuePair;
+import com.gwtext.client.widgets.Button;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.TabPanel;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+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.VerticalLayout;
+/**
+ * Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il
+ * implémente l'interface rafraichissable
+ *
+ * @author aurelien
+ *
+ */
+public class PanneauMetadonneesVue extends TabPanel implements Rafraichissable {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur imediateur = null;
+        /**
+         * Le panneau des Exifs
+         */
+        private PropertyGridPanel ExifGrid = null;
+        /**
+         * Le panneau des Iptc
+         */
+        private PropertyGridPanel IptcGrid = null;
+        /**
+         * La grille pour le panneau des Exifs
+         */
+        private GridView gViewExif = null;
+        /**
+         * La grille pour le panneau de Iptc
+         */
+        private GridView gViewIptc = null;
+        /**
+         * L'onglet des Exifs
+         */
+        private Panel panneauExifGrid = null;
+        /**
+         * L'onglet des Iptc
+         */
+        private Panel panneauIptcGrid = null;
+        /**
+         * L'onglet des infos
+         */
+        private Panel panneauInfoGrid = null;
+        /**
+         * L'onglet des mots clés
+         */
+        private ArbreMotsClesVue panneauMotsCles = null;
+        /**
+         * Le champ commentaire
+         */
+        private TextField commentaireGeneral = null;
+        /**
+         * Le champ date
+         */
+        private DateField dateImage = null;
+        /**
+         * La mini liste des observations
+         */
+        private MiniListeObservationVue miniListeObservation = null ;
+        /**
+         * Le bouton de validation
+         */
+        Button validerInfo = null;
+        /**
+         * Barre de notation
+         */
+        BarreNotationVue noteVue = null;
+        /**
+         * Booleen d'instanciation
+         */
+        boolean estInstancie = false;
+        /**
+         * Constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private PanneauMetadonneesVue() {
+                super();
+        }
+        /**
+         * Constructeur avec argument
+         *
+         * @param im
+         */
+        public PanneauMetadonneesVue(ImageMediateur im) {
+                super();
+                // on associe le médiateur
+                imediateur = im;
+                // on crée et dispose les panneaux et les champs
+                panneauExifGrid = new Panel("Exif");
+                panneauIptcGrid = new Panel("Iptc");
+                panneauInfoGrid = new Panel("info");
+                panneauMotsCles = new ArbreMotsClesVue(im);
+                panneauMotsCles.setHeight("500px");
+                Panel sousPanneauInfosGenerales = new Panel("Infos Générales");
+                sousPanneauInfosGenerales.setLayout(new VerticalLayout());
+                sousPanneauInfosGenerales.setBorder(false);
+                sousPanneauInfosGenerales.setHeight(200);
+                sousPanneauInfosGenerales.setAutoWidth(true);
+                sousPanneauInfosGenerales.setMargins(5);
+                sousPanneauInfosGenerales.setPaddings(5);
+                sousPanneauInfosGenerales.setCollapsible(true);
+                Label labelComm = new Label("Commentaires :");
+                labelComm.setHeight("20px");
+                commentaireGeneral = new TextArea();
+                commentaireGeneral.setWidth("90%");
+                Label labelDate = new Label("Date :");
+                Label labelNote = new Label("Note :");
+                panneauMotsCles.setBorder(false);
+                labelDate.setHeight("20px");
+                dateImage = new DateField();
+                dateImage.setAutoWidth(true);
+                dateImage.setFormat("d/m/Y");
+                validerInfo = new Button("OK");
+                noteVue = new BarreNotationVue(im, 5);
+                miniListeObservation = new MiniListeObservationVue(im) ;
+                sousPanneauInfosGenerales.add(labelComm);
+                sousPanneauInfosGenerales.add(commentaireGeneral);
+                sousPanneauInfosGenerales.add(labelDate);
+                sousPanneauInfosGenerales.add(dateImage);
+                sousPanneauInfosGenerales.add(labelNote);
+                sousPanneauInfosGenerales.add(noteVue);
+                sousPanneauInfosGenerales.add(validerInfo);
+                sousPanneauInfosGenerales.setAutoHeight(true);
+                panneauMotsCles.setAutoHeight(true);
+                panneauInfoGrid.setBorder(false);
+                panneauInfoGrid.setAutoHeight(true);
+                panneauInfoGrid.add(sousPanneauInfosGenerales);
+                panneauInfoGrid.add(panneauMotsCles);
+                this.add(panneauInfoGrid);
+                this.add(panneauExifGrid);
+                this.add(panneauIptcGrid);
+                this.add(miniListeObservation) ;
+                gViewExif = new GridView();
+                gViewExif.setForceFit(true);
+                ExifGrid = new PropertyGridPanel();
+                ExifGrid.setId("meta_exif");
+                ExifGrid.setView(gViewExif);
+                ExifGrid.setNameText("Métadonnées Exif");
+                ExifGrid.setAutoWidth(true);
+                ExifGrid.setAutoHeight(true);
+                ExifGrid.setSorted(false);
+                gViewIptc = new GridView();
+                gViewIptc.setForceFit(true);
+                IptcGrid = new PropertyGridPanel();
+                IptcGrid.setId("meta_iptc");
+                IptcGrid.setView(gViewIptc);
+                IptcGrid.setNameText("Métadonnées IPTC");
+                IptcGrid.setAutoWidth(true);
+                IptcGrid.setAutoHeight(true);
+                IptcGrid.setSorted(false);
+                panneauExifGrid.add(ExifGrid);
+                panneauIptcGrid.add(IptcGrid);
+                // on ajoute les listeners
+                ajouterListeners();
+                // on effectue le rendu
+                this.doLayout(true);
+        }
+        private void ajouterListeners() {
+                // on ajoute un écouteur
+                validerInfo.addListener(new ButtonListenerAdapter() {
+                        // gestion du clic
+                        public void onClick(Button button, EventObject e) {
+                                button.focus();
+                                // lors du clic sur le bouton valider on met à jour les
+                                // commentaires et la date
+                                getIMediateur().mettreAJourInfo(commentaireGeneral.getText(),
+                                                dateImage.getRawValue(), noteVue.getNote());
+                        }
+                });
+                // gestion des clics dans la grille
+                ExifGrid.addGridCellListener(new GridCellListenerAdapter() {
+                        // lors d'un clic d'une cellule
+                        public void onCellClick(GridPanel grid, int rowIndex, int colIndex,
+                                        EventObject e) {
+                                // on empeche l'édition
+                                e.stopEvent();
+                                ExifGrid.stopEditing();
+                        }
+                        // lors du double clic sur une cellule
+                        public void onCellDblClick(GridPanel grid, int rowIndex,
+                                        int colIndex, EventObject e) {
+                                // on empêche l'édition
+                                e.stopEvent();
+                                ExifGrid.stopEditing();
+                        }
+                });
+                IptcGrid.addGridCellListener(new GridCellListenerAdapter() {
+                        // lors d'un clic d'une cellule
+                        public void onCellClick(GridPanel grid, int rowIndex, int colIndex,
+                                        EventObject e) {
+                                // on empeche l'édition
+                                e.stopEvent();
+                                ExifGrid.stopEditing();
+                        }
+                        // lors d'un double clic d'une cellule
+                        public void onCellDblClick(GridPanel grid, int rowIndex,
+                                        int colIndex, EventObject e) {
+                                // on empeche l'édition
+                                e.stopEvent();
+                                ExifGrid.stopEditing();
+                        }
+                });
+        }
+        /**
+         * Desactive visuellement ce panneau
+         */
+        public void desactiverPanneau() {
+                this.setDisabled(true);
+        }
+        /**
+         * Active visuellement ce panneau
+         */
+        public void activerPanneau() {
+                this.setDisabled(false);
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        public ImageMediateur getIMediateur() {
+                return imediateur;
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         *
+         * @param nouvelleDonnees
+         *            les nouvelles données
+         * @param repandreRafraichissement
+         *            le booleen de notification de mise à jour
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si on reçoit un tableau d'objets
+                if (nouvelleDonnees instanceof Object[]) {
+                        // extrait infos, exifs et iptc
+                        Object meta[] = (Object[]) nouvelleDonnees;
+                        String[][] exif = (String[][]) meta[0];
+                        String[][] iptc = (String[][]) meta[1];
+                        String[][] gen = (String[][]) meta[2];
+                        NameValuePair[] exifSource = new NameValuePair[exif.length];
+                        NameValuePair[] iptcSource = new NameValuePair[iptc.length];
+                        int maxLength;
+                        if (exif.length <= iptc.length) {
+                                maxLength = iptc.length;
+                        } else {
+                                maxLength = exif.length;
+                        }
+                        for (int i = 0; i < maxLength; i++) {
+                                if (i < exif.length && !exif[i][0].equals("null")) {
+                                        exifSource[i] = new NameValuePair(exif[i][0], exif[i][1]);
+                                }
+                                if (i < iptc.length && !iptc[i][0].equals("null")) {
+                                        iptcSource[i] = new NameValuePair(iptc[i][0], iptc[i][1]);
+                                }
+                        }
+                        // on met à jour les champs avec la bonne valeur
+                        commentaireGeneral.setValue(gen[0][1]);
+                        dateImage.setRawValue(gen[1][1]);
+                        // et on met à jour les données pour l'affichage
+                        ExifGrid.setSource(exifSource);
+                        IptcGrid.setSource(iptcSource);
+                }
+        }
+        /**
+         * Accesseur pour le panneau des mots clés
+         *
+         * @return the panneauMotsCles
+         */
+        public ArbreMotsClesVue getPanneauMotsCles() {
+                return panneauMotsCles;
+        }
+        public BarreNotationVue getNoteVue() {
+                return noteVue;
+        }
+        public MiniListeObservationVue getMiniListeObservation()
+        {
+                return miniListeObservation ;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/BarreRechercheFiltreVue.java
 New file
 ,0 → 1,161
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Filtrable;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.ui.Label;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.event.KeyListener;
+import com.gwtext.client.widgets.form.TextField;
+/**
+ * Fenêtre de recherche pour les mots clés, contenant un champ texte, et un
+ * bouton cliquable
+ *
+ * @author aurelien
+ *
+ */
+public class BarreRechercheFiltreVue extends Panel implements Rafraichissable,
+                Filtrable {
+        /**
+         * Médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur = null;
+        /**
+         * Barre de recherche
+         *
+         */
+        private TextField champRecherche = null;
+        /**
+         * Booleen d'etat du filtre
+         */
+        private boolean filtreModifie = false;
+        /**
+         * mot(s) à chercher
+         */
+        private String motsAChercher = "";
+        /**
+         * Constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private BarreRechercheFiltreVue() {
+                super();
+        }
+        /**
+         * Constructeur avec médiateur
+         *
+         * @param im
+         */
+        public BarreRechercheFiltreVue(ImageMediateur im) {
+                super();
+                iMediateur = im;
+                Label labelRecherche = new Label("Commentaires :");
+                champRecherche = new TextField();
+                add(labelRecherche);
+                add(champRecherche);
+                setPaddings(5);
+                setBorder(false);
+                setAutoWidth(true);
+                setCollapsible(true);
+                ajouterListeners();
+        }
+        /**
+         * ajoute des listeners
+         */
+        private void ajouterListeners() {
+                // gestion de la touche entrée
+                champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() {
+                        public void onKey(int key, EventObject e) {
+                                valider();
+                                getIMediateur().obtenirPhotoGalerie(
+                                                getIMediateur().getFiltreCommentaires());
+                        }
+                });
+        }
+        /**
+         * Fonction héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                filtreModifie = false;
+        }
+        /**
+         * renvoie l'état du filtre (modifié ou non)
+         *
+         * @return l'état du filtre
+         */
+        public boolean renvoyerEtatFiltre() {
+                return filtreModifie;
+        }
+        /**
+         * Renvoie le nom du filtre
+         *
+         * @return le nom du filtre
+         */
+        public String renvoyerNomFiltre() {
+                return "Recherche Commentaires";
+        }
+        /**
+         * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
+         *
+         * @return un tableau contenant le nom du champ à filtrer et sa valeur
+         */
+        public String[] renvoyerValeursAFiltrer() {
+                valider() ;
+                String[] valeurFiltre = { "ci_meta_comment", motsAChercher };
+                return valeurFiltre;
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Effectue quelque opérations dans la classe et envoie une requête de
+         * données au médiateur
+         */
+        public void valider() {
+                filtreModifie = true;
+                motsAChercher = champRecherche.getText();
+        }
+        /**
+         * Affiche la fenetre
+         */
+        public void afficherFiltre() {
+                champRecherche.setValue(motsAChercher);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/MenuFiltreVue.java
 New file
 ,0 → 1,96
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.widgets.menu.BaseItem;
+import com.gwtext.client.widgets.menu.Item;
+import com.gwtext.client.widgets.menu.Menu;
+import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
+public class MenuFiltreVue extends Menu {
+        /**
+         * Le médiateur associé à la vue
+         */
+        private ImageMediateur iMediateur;
+        /**
+         * Item pour la recherche par mots clés
+         */
+        private Item chercherImage = null;
+        /**
+         * Item pour la recherche sur les commentaires
+         */
+        private Item chercherCommentaire = null;
+        /**
+         * Constructeur sans argument (privé car ne doit être utilisé)
+         */
+        @SuppressWarnings("unused")
+        private MenuFiltreVue() {
+                super();
+        }
+        /**
+         * Constructeur avec paramètre
+         *
+         * @param im
+         *            le médiateur à associer
+         */
+        public MenuFiltreVue(ImageMediateur im) {
+                super();
+                iMediateur = im;
+                // on construit le menu
+                chercherImage = new Item("Filtrer par les mots clés");
+                chercherCommentaire = new Item("Filtrer par les commentaires");
+                addItem(chercherImage);
+                addItem(chercherCommentaire);
+                // on ajoute les listeners
+                ajouterListeners();
+        }
+        /**
+         * Ajoute les listeners pour la gestions des évènements
+         */
+        private void ajouterListeners() {
+                this.addListener(new MenuListenerAdapter() {
+                        // gestion du clic sur un item
+                        public void onItemClick(BaseItem item, EventObject e) {
+                                // si c'est la recherche par mots clé
+                                if (item.equals(chercherImage)) {
+                                        // on notifie le médiateur
+                                        // getIMediateur().afficherFiltreMotsCles() ;
+                                }
+                                // si c'est la recherche par commentaires
+                                if (item.equals(chercherCommentaire)) {
+                                        // on notifie le médiateur
+                                        // getIMediateur().afficherFiltreCommentaires() ;
+                                }
+                                // enfin, on cache le menu
+                                hide();
+                        }
+                });
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
 New file
 ,0 → 1,336
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Filtrable;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import com.google.gwt.user.client.ui.Label;
+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;
+/**
+ * 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;
+        /**
+         * Les mots clés en cours
+         */
+        private String motsClesEncours = "";
+        /**
+         * Le treepanel qui affiche l'arbre
+         */
+        private TreePanel arbreMotsCles = null;
+        /**
+         * booléen d'initialisation
+         */
+        private boolean estInstancie = false;
+        /**
+         * booléen d'etat
+         */
+        private boolean filtreModifie = false;
+        /**
+         * 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();
+                // this.setLayout(new VerticalLayout());
+                iMediateur = im;
+                // on crée le conteneur de l'arbre
+                Label labelRecherche = new Label("Mots clés :");
+                arbreMotsCles = new TreePanel();
+                this.setPaddings(5);
+                this.setBorder(false);
+                this.setCollapsible(true);
+                this.setAutoWidth(true);
+                add(labelRecherche);
+                // on ajoute les listeners
+                ajouterListenersPanel();
+                estInstancie = false;
+        }
+        /**
+         * Ajoute les listeners pour le rendu du panel
+         */
+        private void ajouterListenersPanel() {
+                this.addListener(new PanelListenerAdapter() {
+                        // on instancie réellement les composants au moment du rendu pour
+                        // accélérer l'affichage
+                        // et éviter des bugs
+                        public void onRender(Component component) {
+                                // on interdit le drag and drop dans l'arbre
+                                arbreMotsCles.setEnableDD(false);
+                                arbreMotsCles.setId("x-view-tree-filter");
+                                arbreMotsCles.setAutoWidth(false);
+                                arbreMotsCles.setAutoScroll(true);
+                                arbreMotsCles.setBorder(false);
+                                // on crée une racine pour l'arbre
+                                TreeNode root = new TreeNode("Tags");
+                                root.setId("racine_filtre");
+                                String[] usObject = { "Mots clés", "racine" };
+                                root.setUserObject(usObject);
+                                arbreMotsCles.setRootNode(root);
+                                arbreMotsCles.setRootVisible(true);
+                                arbreMotsCles.setBorder(false);
+                                // on met en forme le layout
+                                ((Panel) component).add(arbreMotsCles);
+                                // on ajoute les listeners d'évenements
+                                ajouterListeners();
+                                // et on demande l'arbre des mots clés
+                                getIMediateur()
+                                                .obtenirArbreMotsCles(
+                                                                getIMediateur().getPanneauFiltres()
+                                                                                .getMotsClesFiltre());
+                                // enfin on considère le composant comme instancié
+                                estInstancie = true;
+                        }
+                });
+        }
+        /**
+         * ajoute les listeners pour les boutons et le cochage des mots clés
+         */
+        private void ajouterListeners() {
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRaffraichissement) {
+                // si on a reçu un arbre
+                if (nouvelleDonnees instanceof Tree) {
+                        Tree nouvelArbre = (Tree) nouvelleDonnees;
+                        // on vide tous les noeuds
+                        arbreMotsCles.getRootNode().eachChild(new NodeTraversalCallback() {
+                                public boolean execute(Node node) {
+                                        node.remove();
+                                        return true;
+                                }
+                        });
+                        // et on recopie le nouvel arbre
+                        copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
+                                        .getRootNode());
+                        // si l'arbre n'était pas encore considéré comme instancié
+                        if (!estInstancie) {
+                                // on signale que oui
+                                estInstancie = true;
+                        }
+                        // l'état du filtre est réinitialisé
+                        filtreModifie = false;
+                        show();
+                }
+                if (nouvelleDonnees instanceof TreeNode) {
+                        TreeNode nd = (TreeNode) nouvelleDonnees;
+                        // si le noeud n'existe pas déjà c'est un ajout
+                        if (arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre") == null) {
+                                // donc on ne fait rien de spécial
+                        }
+                        // si le noeud existe déjà c'est un déplacement
+                        else {
+                                // alors on supprime d'abord le noeud concerné
+                                arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre")
+                                                .remove();
+                        }
+                        // on cherche le père du nouveau noeud
+                        Node ndPereOriginal = nd.getParentNode();
+                        String idPereFiltre = ndPereOriginal.getId() + "_filtre";
+                        String[] usObj = (String[]) nd.getUserObject();
+                        TreeNode child = new TreeNode(usObj[0]);
+                        child.setId(usObj[1] + "_filtre");
+                        child.setChecked(false);
+                        child.setUserObject(usObj);
+                        arbreMotsCles.getNodeById(idPereFiltre).appendChild(child);
+                        // et on ajoute le nouveau noeud à son père
+                        copierFilsNoeud(nd, child);
+                }
+                // si on reçoit une string
+                if (nouvelleDonnees instanceof String) {
+                        String idSupp = (String) nouvelleDonnees + "_filtre";
+                        // c'est une suppression et si le noeud existe bien
+                        if (arbreMotsCles.getTree().getNodeById(idSupp) != null) {
+                                // on le supprime
+                                arbreMotsCles.getTree().getNodeById(idSupp).remove();
+                        }
+                }
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Accesseur pour le panneau contenant l'arbre
+         *
+         * @return le panneau de l'arbre des mots clés
+         */
+        public TreePanel getArbreMotsCles() {
+                return arbreMotsCles;
+        }
+        /**
+         * Méthode héritée de Filtrable renvoie le nom du filtre
+         */
+        public String renvoyerNomFiltre() {
+                return "mots clés";
+        }
+        /**
+         * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
+         *
+         * @return un tableau contenant le nom du champ à filtrer et sa valeur
+         */
+        public String[] renvoyerValeursAFiltrer() {
+                valider();
+                String[] valeursFiltrees = { "ci_meta_mots_cles", motsClesEncours };
+                return valeursFiltrees;
+        }
+        /**
+         * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
+         * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
+         *
+         * @param ndPereOriginal
+         *            le père des noeuds de l'arbre original
+         * @param ndPereCopie
+         *            le père qui va recevoir les copies
+         */
+        private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
+                if (ndPereCopie != null && ndPereOriginal != null) {
+                        Node[] ndNodeFils = ndPereOriginal.getChildNodes();
+                        for (int i = 0; i < ndNodeFils.length; i++) {
+                                String[] usObj = (String[]) ndNodeFils[i].getUserObject();
+                                TreeNode child = new TreeNode(usObj[0]);
+                                child.setId(usObj[1] + "_filtre");
+                                child.setChecked(false);
+                                child.setUserObject(usObj);
+                                ndPereCopie.appendChild(child);
+                                if (!ndNodeFils[i].isLeaf()) {
+                                        copierFilsNoeud(ndNodeFils[i], child);
+                                }
+                        }
+                }
+        }
+        /**
+         * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
+         */
+        public boolean renvoyerEtatFiltre() {
+                return filtreModifie;
+        }
+        public void valider() {
+                if (estInstancie) {
+                        // on vide les mots clés en cours
+                        motsClesEncours = "";
+                        // pour chaque noeud à partir de la racine
+                        getArbreMotsCles().getRootNode().cascade(
+                                        new NodeTraversalCallback() {
+                                                // on éxécute une fonction
+                                                public boolean execute(Node node) {
+                                                        // on récupère le mot clé associé au noeud et ses
+                                                        // infos
+                                                        TreeNode tn = getArbreMotsCles().getNodeById(
+                                                                        node.getId());
+                                                        String[] usObject = (String[]) tn.getUserObject();
+                                                        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;
+                                                }
+                                        });
+                        // on suppose que le filtre a change
+                        filtreModifie = true;
+                }
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/GalerieImageVue.java
 New file
 ,0 → 1,359
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.interfaces.VueListable;
+import com.google.gwt.user.client.Element;
+import com.gwtext.client.core.EventObject;
+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.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.grid.GridDragData;
+/**
+ * Galerie d'images miniatures Avec barre de pagination
+ *
+ * @author aurelien
+ */
+public class GalerieImageVue extends Panel implements Rafraichissable,
+                VueListable {
+        /**
+         * 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 pageToolBarVue pt = null;
+        /**
+         * Booleen indiquant si la galerie est instanciée ou pas
+         */
+        private boolean estInstancie = false;
+        /**
+         * Constructeur sans argument, privé car ne doit pas être utilisé
+         */
+        @SuppressWarnings("unused")
+        private GalerieImageVue() {
+                super();
+        }
+        /**
+         * Constructeur avec argument
+         *
+         * @param im
+         *            le médiateur avec lequel la vue va communiquer
+         */
+        public GalerieImageVue(ImageMediateur im) {
+                super("Galerie");
+                iMediateur = im;
+                // on ajoute des listeners au composant tout entier
+                this.addListener(new ContainerListenerAdapter() {
+                        // pour gagner du temps on n'instancie la vue en elle même que lors
+                        // du premier affichage (lazy rendering)
+                        public void onShow(Component component) {
+                                if (!estInstancie) {
+                                        initialiser();
+                                }
+                        }
+                });
+                // et on ajoute la tool bar
+                pt = new pageToolBarVue(im);
+                this.setBottomToolbar(pt);
+        }
+        /**
+         * Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la
+         * vue de données
+         */
+        public void ajouterListenersDataView() {
+                // ajout de listeners pour la gestion de la selection
+                // dans la galerie
+                dView.addListener(new DataViewListenerAdapter() {
+                        // gestion du clic sur une image
+                        public void onClick(DataView source, int index, Element node,
+                                        EventObject e) {
+                                // on en notifie le médiateur
+                                getIMediateur().clicGalerieImage(index, node, e);
+                        }
+                        // gestion du clic droit
+                        public void onContextMenu(DataView source, int index, Element node,
+                                        EventObject e) {
+                                // on stoppe l'évenement
+                                e.stopEvent();
+                                // et on notifie le médiateur
+                                getIMediateur().montrerContextMenu(e);
+                        }
+                        // gestion du double clic
+                        public void onDblClick(DataView source, int index, Element node,
+                                        EventObject e) {
+                                // on notife le mediateur
+                                getIMediateur().clicGalerieImage(index, node, e);
+                        }
+                        // gestion des actions en fonction de la selection
+                        public void onSelectionChange(DataView view, Element[] selections) {
+                                // s'il n'y a aucun élement sélectionné
+                                if (selections.length <= 0) {
+                                        // on en notifie le médiateur
+                                        getIMediateur().aucuneSelection();
+                                } else {
+                                        // sinon on notifie le médiateur
+                                        getIMediateur().selection();
+                                        // et on lui demande de synchroniser la séléction avec les
+                                        // autres vues
+                                        getIMediateur().synchroniserSelection("galerie");
+                                }
+                        }
+                });
+        }
+        /**
+         * Accesseur pour la dataview
+         *
+         * @return la dataview
+         */
+        public DataView getDView() {
+                return dView;
+        }
+        /**
+         * Renvoie les ids des images sélectionnées
+         *
+         * @return un tableau de String contenant les identifiants des images
+         *         sélectionnées
+         */
+        public String[] getIdSelectionnees() {
+                Record[] selection = getDView().getSelectedRecords();
+                int taille = selection.length;
+                String id_selection[] = new String[taille];
+                for (int i = 0; i < selection.length; i++) {
+                        id_selection[i] = selection[i].getAsString("num_image");
+                }
+                return id_selection;
+        }
+        /**
+         * Accesseur pour le médiateur
+         *
+         * @return le médiateur associé à la vue
+         */
+        public ImageMediateur getIMediateur() {
+                return iMediateur;
+        }
+        /**
+         * Accesseur pour le store
+         *
+         * @return le store associé à la vue
+         */
+        public Store getSt() {
+                return st;
+        }
+        /**
+         * Accesseur pour la toolbar
+         *
+         * @return la toolbar associée à la vue
+         */
+        public pageToolBarVue 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'><img src='{url_image_M}' title='{num_image}'></div>",
+                                                "<span>{nom}</span></div>", "</tpl>",
+                                                "<div class='x-clear'></div>" });
+                // pour des raisons de performances on compile le template en une
+                // fonction
+                template.compile();
+                // la dataview affichera les images en accord avec le template
+                // cree precedemment
+                dView = new DataView("div.thumb-wrap") {
+                        public void prepareData(Data data) {
+                                data.setProperty("shortName", Format.ellipsis(data
+                                                .getProperty("num_image"), 15));
+                        }
+                };
+                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("Aucune image à afficher");
+                // creation du store
+                FieldDef defNumImage = new IntegerFieldDef("num_image");
+                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[] defTab = { defNumImage, defDatImage, defLieImage,
+                                defAppImage, defUrlImageS, defUrlImageM, defUrlImage };
+                RecordDef rd = new RecordDef(defTab);
+                st = new Store(rd);
+                dView.setStore(st);
+                this.getDView().setLoadingText("chargement");
+                // ajouts de la gestion des evenements pour la dataview
+                ajouterListenersDataView();
+                configDragAndDrop() ;
+                this.add(dView);
+                // enfin on envoie une demande de données au médiateur
+                getIMediateur().obtenirPhotoGalerie(this);
+                // et on déclare le composant comme instancié
+                estInstancie = true;
+        }
+        public void configDragAndDrop()
+        {
+                // on fabrique la nouvelle configuration
+                // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
+                DropTargetConfig dtc = new DropTargetConfig();
+                dtc.setdDdGroup("DragGroupName");
+                //La drop target permet de gérer l'évenement onDrop sur l'élement courant
+                @SuppressWarnings("unused")
+                DropTarget tg = new DropTarget(this, dtc)
+                {
+                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){
+                                // si les données proviennent d'une grille
+                                if(data instanceof GridDragData)
+                        {
+                                        // on appelle le médiateur
+                                        return iMediateur.lierObsDD(source, e, data,getId()) ;
+                        }
+                                return false ;
+                        }
+                        public String notifyOver(DragSource source, EventObject e, DragData data){
+                            return "x-dd-drop-ok";
+                        }
+                };
+        }
+        /**
+         * Méthode héritée de l'interface rafraichissable
+         */
+        public void rafraichir(Object nouvelleDonnees,
+                        boolean repandreRafraichissement) {
+                // si l'objet reçu est un store
+                if (nouvelleDonnees instanceof Store) {
+                        st = (Store) nouvelleDonnees;
+                        // on le charge
+                        st.load();
+                        // on l'affecte à la vue
+                        dView.setStore(st);
+                        // et on rafrachit la vue
+                        dView.refresh();
+                }
+                // 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);
+                }
+                // si c'est la première mise à jour que l'on reçoit
+                if (!estInstancie) {
+                        // alors le composant est considéré comme instancié
+                        estInstancie = true;
+                }
+        }
+        /**
+         * 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);
+        }
+}

 /trunk/src/org/tela_botanica/client/vues/EtatConnexionVue.java
 New file
 ,0 → 1,154
+/**
+ David Delon david.delon@clapas.net 2007
+ */
+/*
+ * EtatConnexionVue.java  : affichage information portant sur le statut de la connexion utilisateur
+ *
+ *
+ * 1: Le programme affiche le statut connecte si l'utilisateur s'est connecte precedemment, sinon s'affiche le statut deconnecte
+ * 2: Le programme arme les actions liees a la connection ou a la deconnection
+ *    - Connection : affichage de la boite de connexion
+ *    - Deconnexion : appel du service de deconnexion, et appel de la re-initialisation de l'affichage pour le nouvel identifiant utilisateur obtenu (identifiant  de session)
+ */
+package org.tela_botanica.client.vues;
+import org.tela_botanica.client.CarnetEnLigneMediateur;
+import com.google.gwt.user.client.ui.ClickListener;
+import com.google.gwt.user.client.ui.HTML;
+import com.google.gwt.user.client.ui.Widget;
+import com.gwtext.client.widgets.Panel;
+/**
+ * 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 labelEtatConnexion = null;
+  /**
+   * Booleen indiquant si utilisateur connecte
+   *
+   */
+  private boolean connecte = false ;
+  public EtatConnexionVue(CarnetEnLigneMediateur cm)  {
+        carnetEnLigneMediateur=cm;
+    this.setSize(800,20) ;
+    this.setBodyBorder(false) ;
+    this.setBorder(false) ;
+        // Pas de word wrap
+        labelEtatConnexion=new HTML("",false);
+        this.add(labelEtatConnexion);
+        ajouterListeners();
+        }
+   public void ajouterListeners() {
+        labelEtatConnexion.addClickListener(
+                        new ClickListener() {
+                                public void onClick(Widget sender) {
+                                        // Non connecte ? Lien  vers dialogue de connection
+                                        if (!connecte) {
+                                                carnetEnLigneMediateur.afficherDialogueConnexion();
+                                        }
+                                        else {
+                                                carnetEnLigneMediateur.deconnecterUtilisateur();
+                                        }
+                                }
+                        }
+        );
+        }
+/**
+ * Affichage de l'etat de connexion
+ * @param text
+ * @param connecte
+ */
+public void setEtat(String text, boolean connecte) {
+        labelEtatConnexion.setHTML(text);
+        this.connecte=connecte;
+}
+}
+/* +--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/FormulaireSaisieObservationVue.java
 New file
 ,0 → 1,545
+package org.tela_botanica.client.vues;
+import java.util.Iterator;
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.ListeReferentielCommune;
+import org.tela_botanica.client.modeles.ListeReferentielNom;
+import org.tela_botanica.client.modeles.ReferentielCommune;
+import org.tela_botanica.client.modeles.ReferentielNom;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import com.gwtext.client.core.EventCallback;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.core.ListenerConfig;
+import com.gwtext.client.core.Position;
+import com.gwtext.client.data.ArrayReader;
+import com.gwtext.client.data.FieldDef;
+import com.gwtext.client.data.MemoryProxy;
+import com.gwtext.client.data.RecordDef;
+import com.gwtext.client.data.Store;
+import com.gwtext.client.data.StringFieldDef;
+import com.gwtext.client.widgets.Button;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.form.ComboBox;
+import com.gwtext.client.widgets.form.DateField;
+import com.gwtext.client.widgets.form.FormPanel;
+import com.gwtext.client.widgets.form.TextField;
+import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
+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.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;
+        private DateField date = null;
+        private TextField lieudit = null;
+        private TextField station = null;
+        private TextField milieu = null;
+        private TextField comment = null;
+        private ComboBox  commune = null;
+        private ComboBox  espece = null;
+        private Button boutonOK = new Button("Ok");
+        private Button boutonAnnuler = new Button("Annuler");
+        private boolean selectionCommune=false;
+        private boolean selectionEspece=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 ;
+        /**
+         * Constructeur sans argument (privé car ne doit pas être utilisé)
+         */
+        private FormulaireSaisieObservationVue()
+        {
+                super() ;
+        }
+        /**
+         * Constructeur avec argument
+         * @param im
+         */
+        public FormulaireSaisieObservationVue(ObservationMediateur obs)
+        {
+                // on associe le médiateur
+                observationMediateur = obs ;
+                this.setHeader(true);
+                this.setTitle("Saisie");
+                this.setCollapsible(true) ;
+                FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
+                panneauFormulaire.setBorder(false);
+                // Panneau intermediaire qui contient deux colonnes de formulaire
+                Panel panneauIntermediaire = new Panel();
+                panneauIntermediaire.setLayout(new ColumnLayout());
+                panneauIntermediaire.setBorder(false);
+                //create first panel and add fields to it
+                Panel panneauPremierColonne = new Panel();
+                panneauPremierColonne.setLayout(new FormLayout());
+                panneauPremierColonne.setBorder(false);
+                //create second panel and add fields to it
+            Panel panneauSecondeColonne = new Panel();
+                panneauSecondeColonne.setLayout(new FormLayout());
+                panneauSecondeColonne.setBorder(false);
+        /*
+            //    creation du store
+                FieldDef defCommune = new StringFieldDef("commune");
+                FieldDef defDepartement = new StringFieldDef("departement");
+                FieldDef[] defTab = { defCommune, defDepartement};
+                RecordDef rd = new RecordDef(defTab);
+                store = new Store(rd);
+                //store.load();*/
+                commune=new ComboBox("Commune","commune",275 );
+                final String resultTplCommune = "<div class=\"search-item-commune\">{commune}</div>";
+                commune.setTpl(resultTplCommune);
+                commune.setMode(ComboBox.REMOTE);
+                // commune.setPageSize(10); // Ne fonctionne pas
+                commune.setItemSelector("div.search-item-commune");
+                commune.setTypeAhead(true);
+                commune.setLoadingText("Recherche...");
+                commune.setHideTrigger(true);
+            panneauPremierColonne.add(commune);
+            station = new TextField("Station", "station", 275);
+            station.setAllowBlank(true);
+            panneauPremierColonne.add(station);
+            date = new DateField("Date", "date", 100);
+            date.setAllowBlank(true);
+            date.setFormat("d/m/Y") ;
+            panneauPremierColonne.add(date);
+                espece=new ComboBox("Espèce","nom",275 );
+                final String resultTplEspece = "<div class=\"search-item-espece\">{nom}</div>";
+                espece.setTpl(resultTplEspece);
+                espece.setMode(ComboBox.REMOTE);
+                // commune.setPageSize(10); // Ne fonctionne pas
+                espece.setItemSelector("div.search-item-espece");
+                espece.setTypeAhead(true);
+                espece.setLoadingText("Recherche...");
+                espece.setHideTrigger(true);
+            panneauPremierColonne.add(espece);
+            comment = new TextField("Notes", "comment", 275);
+            comment.setAllowBlank(true);
+            panneauPremierColonne.add(comment);
+            lieudit = new TextField("Lieu-dit", "lieudit", 275);
+            lieudit.setAllowBlank(true);
+            panneauSecondeColonne.add(lieudit);
+            milieu = new TextField("Milieu", "milieu", 275);
+            milieu.setAllowBlank(true);
+            panneauSecondeColonne.add(milieu);
+                panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5));
+                panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5));
+                panneauFormulaire.add(panneauIntermediaire);
+                panneauFormulaire.addButton(boutonOK);
+                panneauFormulaire.addButton(boutonAnnuler);
+                this.add(panneauFormulaire) ;
+                this.setAutoHeight(true);
+                // on ajoute les listeners
+                ajouterListeners() ;
+        }
+        private void ajouterListeners()
+        {
+                // Listener completion communne
+                   commune.addListener(new ComboBoxListenerAdapter() {
+                     public void onSelect(ComboBox comboBox, Record record, int index) {
+                         commune.setValue(record.getAsString("commune"));
+                         selectionCommune=true;
+                     }
+                 });
+                        ListenerConfig listenerConfigCommune=new ListenerConfig();
+                        listenerConfigCommune.setDelay(10);
+                        listenerConfigCommune.setStopPropagation(false);
+                        listenerConfigCommune.setStopEvent(false);
+                    commune.addKeyPressListener(new EventCallback()     {
+                            public void execute(EventObject e) {
+                                          switch(e.getKey()) {
+                                          case KEY_ALT:
+                                      case KEY_CTRL:
+                                      case KEY_DOWN:
+                                      case KEY_END:
+                                      case KEY_ESCAPE:
+                                      case KEY_HOME:
+                                      case KEY_LEFT:
+                                      case KEY_PAGEDOWN:
+                                      case KEY_PAGEUP:
+                                      case KEY_RIGHT:
+                                      case KEY_SHIFT:
+                                      case KEY_TAB:
+                                      case KEY_UP:
+                                        break;
+                                      case KEY_ENTER:
+                                         if (selectionCommune) {
+                                                 selectionCommune=false;
+                                         }
+                                         else {
+                                                // lancer mise a jour
+                                         }
+                                          break;
+                                      default:
+                                          obtenirListeReferentielCommune();
+                                        break;
+                                    }
+                                }
+                                },    listenerConfigCommune
+                        );
+                        // Listener completion espece
+                        espece.addListener(new ComboBoxListenerAdapter() {
+                     public void onSelect(ComboBox comboBox, Record record, int index) {
+                         espece.setValue(record.getAsString("nom"));
+                         selectionEspece=true;
+                     }
+                 });
+                        ListenerConfig listenerConfigEspece=new ListenerConfig();
+                        listenerConfigEspece.setDelay(10);
+                        listenerConfigEspece.setStopPropagation(false);
+                        listenerConfigEspece.setStopEvent(false);
+                        espece.addKeyPressListener(new EventCallback()  {
+                            public void execute(EventObject e) {
+                                          switch(e.getKey()) {
+                                          case KEY_ALT:
+                                      case KEY_CTRL:
+                                      case KEY_DOWN:
+                                      case KEY_END:
+                                      case KEY_ESCAPE:
+                                      case KEY_HOME:
+                                      case KEY_LEFT:
+                                      case KEY_PAGEDOWN:
+                                      case KEY_PAGEUP:
+                                      case KEY_RIGHT:
+                                      case KEY_SHIFT:
+                                      case KEY_TAB:
+                                      case KEY_UP:
+                                        break;
+                                      case KEY_ENTER:
+                                         if (selectionEspece) {
+                                                 selectionEspece=false;
+                                         }
+                                         else {
+                                                // lancer mise a jour
+                                         }
+                                          break;
+                                      default:
+                                          obtenirListeReferentielNom();
+                                        break;
+                                    }
+                                }
+                                },    listenerConfigEspece
+                        );
+                boutonOK.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                        //observationMediateur.ajouterObservation(this);
+                        }
+                });
+                // on ajoute un écouteur
+                /*validerInfo.addListener(new ButtonListenerAdapter() {
+                        // gestion du clic
+                        public void onClick(Button button, EventObject e) {
+                                // lors du clic sur le bouton valider on met à jour les commentaires et la date
+                //      getIMediateur().mettreAJourInfo(commentaireGeneral.getText(), dateImage.getRawValue(), noteVue.getNote()) ;
+                        }
+                });
+                */
+        }
+        /**
+         * Desactive visuellement ce panneau
+         */
+        public void desactiverPanneau()
+        {
+                this.setDisabled(true) ;
+        }
+        /**
+         * Active visuellement ce panneau
+         */
+        public void activerPanneau()
+        {
+                this.setDisabled(false) ;
+        }
+        public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
+                //
+                // si l'on a reçu une liste de commune
+                        if(nouvelleDonnees instanceof ListeReferentielCommune)
+                        {
+                                        ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ;
+                                        Object[][] communeData = new Object[data.size()][2];
+                                        int i = 0 ;
+                                        // on la parse et on récupère les informations quiç nous interessent
+                                        for (Iterator it = data.keySet().iterator(); it.hasNext();)
+                                        {
+                                                ReferentielCommune ref=(ReferentielCommune) data.get(it.next());
+                                                communeData[i][0]= ref.getCommune();
+                                                communeData[i][1]= ref.getDepartement();
+                                                i++ ;
+                                        }
+                                           //     creation du store
+                                        FieldDef defCommune = new StringFieldDef("commune");
+                                        FieldDef defDepartement = new StringFieldDef("departement");
+                                        FieldDef[] defTab = { defCommune, defDepartement};
+                                        RecordDef rd = new RecordDef(defTab);
+                                        final MemoryProxy dataProxy = new MemoryProxy(communeData);
+                                        final ArrayReader reader = new ArrayReader(rd);
+                                        Store store=new Store(dataProxy,reader);
+                                        store.load() ;
+                                        commune.setStore(store);
+                        }
+//                       si l'on a reçu une liste de nom
+                        if(nouvelleDonnees instanceof ListeReferentielNom)
+                        {
+                                        ListeReferentielNom data = (ListeReferentielNom) nouvelleDonnees ;
+                                        Object[][] nomData = new Object[data.size()][2];
+                                        int i = 0 ;
+                                        // on la parse et on récupère les informations quiç nous interessent
+                                        for (Iterator it = data.keySet().iterator(); it.hasNext();)
+                                        {
+                                                ReferentielNom ref=(ReferentielNom) data.get(it.next());
+                                                nomData[i][0]= ref.getNom();
+                                                nomData[i][1]= ref.getNumeroNom();
+                                                i++ ;
+                                        }
+                                           //     creation du store
+                                        FieldDef defNom = new StringFieldDef("nom");
+                                        FieldDef defNumeroNom = new StringFieldDef("numeroNom");
+                                        FieldDef[] defTab = { defNom, defNumeroNom};
+                                        RecordDef rd = new RecordDef(defTab);
+                                        final MemoryProxy dataProxy = new MemoryProxy(nomData);
+                                        final ArrayReader reader = new ArrayReader(rd);
+                                        Store store=new Store(dataProxy,reader);
+                                        store.load() ;
+                                        espece.setStore(store);
+                        }
+        }
+        public void obtenirListeReferentielCommune() {
+         String com=commune.getText().replaceAll(" ","/");
+         com=com.replaceAll("%","");
+         observationMediateur.obtenirListeReferentielCommune(this,com);
+        }
+        public void obtenirListeReferentielNom() {
+          String esp=espece.getText().replaceAll(" ","/");
+          esp=esp.replaceAll("%","");
+          observationMediateur.obtenirListeReferentielNom(this,esp);
+        }
+}

 /trunk/src/org/tela_botanica/client/interfaces/IRetourImage.java
 New file
 ,0 → 1,9
+package org.tela_botanica.client.interfaces;
+import org.tela_botanica.client.modeles.ListeImageCarnet;
+public interface IRetourImage {
+        public void onRetour(ListeImageCarnet listeImage);
+}

 /trunk/src/org/tela_botanica/client/interfaces/IdVue.java
 New file
 ,0 → 1,90
+package org.tela_botanica.client.interfaces;
+import org.tela_botanica.client.image.ImageMediateur;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.widgets.Button;
+import com.gwtext.client.widgets.Panel;
+import com.gwtext.client.widgets.Window;
+import com.gwtext.client.widgets.event.ButtonListenerAdapter;
+import com.gwtext.client.widgets.event.KeyListener;
+import com.gwtext.client.widgets.event.WindowListenerAdapter;
+import com.gwtext.client.widgets.form.TextField;
+public class IdVue extends Window implements Rafraichissable {
+        private ImageMediateur iMediateur;
+        private TextField champId = null;
+        private Button ok = null;
+        public IdVue(ImageMediateur im) {
+                super("Identification");
+                iMediateur = im;
+                champId = new TextField();
+                ok = new Button("OK");
+                add(champId);
+                add(ok);
+                setSize(156, 75);
+                setClosable(false);
+                setModal(true);
+                this.setCloseAction(HIDE);
+                ajouterListeners();
+        }
+        private void ajouterListeners() {
+                // gestion du clic sur le bouton
+                ok.addListener(new ButtonListenerAdapter() {
+                        public void onClick(Button button, EventObject e) {
+                                valider();
+                        }
+                });
+                // gestion de la touche entrée
+                champId.addKeyListener(EventObject.ENTER, new KeyListener() {
+                        public void onKey(int key, EventObject e) {
+                                valider();
+                        }
+                });
+                this.addListener(new WindowListenerAdapter() {
+                        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();
+        }
+        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/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 restye 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/Filtrable.java
 New file
 ,0 → 1,43
+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();
+}

 /trunk/src/org/tela_botanica/client/interfaces/iRetourUtilisateur.java
 New file
 ,0 → 1,8
+package org.tela_botanica.client.interfaces;
+import org.tela_botanica.client.modeles.Utilisateur;
+public interface iRetourUtilisateur {
+        public void onRetour(Utilisateur utilisateur);
+}

 /trunk/src/org/tela_botanica/client/interfaces/FournisseurListe.java
 New file
 ,0 → 1,21
+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 restye de l'objet
+ * @author aurelien
+ *
+ */
+public interface FournisseurListe {
+        /**
+         * 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 obtenirListeDonnees(final Rafraichissable r, String critere);
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /trunk/src/org/tela_botanica/client/interfaces/iRetourObservation.java
 New file
 ,0 → 1,8
+package org.tela_botanica.client.interfaces;
+import org.tela_botanica.client.modeles.Observation;
+public interface iRetourObservation {
+          public void onRetour(Observation observation);
+}

 /trunk/src/org/tela_botanica/client/interfaces/iMediateur.java
 New file
 ,0 → 1,10
+package org.tela_botanica.client.interfaces;
+/*
+ * Interface Mediateur
+ *
+ */
+public interface iMediateur {
+}

 /trunk/src/org/tela_botanica/client/CarnetEnLigneModele.java
 New file
 ,0 → 1,92
+package org.tela_botanica.client;
+/**
+ * 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.
+ */
+import org.tela_botanica.client.interfaces.Rafraichissable;
+import org.tela_botanica.client.modeles.Configuration;
+import org.tela_botanica.client.modeles.UtilisateurAsynchroneDAO;
+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()
+        {
+                        if(!estInstancie)
+                        {
+                                estInstancie = true ;
+                                return new CarnetEnLigneModele() ;
+                        }
+                        else
+                        {
+                                return null ;
+                        }
+        }
+        private CarnetEnLigneModele() {
+                config = new Configuration();
+        }
+        public void deconnecterUtilisateur(Rafraichissable r, String user) {
+                new UtilisateurAsynchroneDAO(this).deconnecterUtilisateur(r,user );
+        }
+        public void connecterUtilisateur(Rafraichissable r, String login , String password) {
+                new UtilisateurAsynchroneDAO(this).connecteUtilisateur(r,login, password );
+        }
+        public void getEtatUtilisateur(Rafraichissable r) {
+                new UtilisateurAsynchroneDAO(this).getEtatUtilisateur(r);
+        }
+        /**
+         * Accesseur pour la configuration en cours d'utilisation
+         *
+         * @return la configuration
+         */
+        public Configuration getConfig() {
+                return config;
+        }
+}

 /trunk/src/org/tela_botanica/client/cel2.java
 New file
 ,0 → 1,32
+package org.tela_botanica.client;
+import org.tela_botanica.client.image.ImageMediateur;
+import org.tela_botanica.client.observation.ObservationMediateur;
+import com.google.gwt.core.client.EntryPoint;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.gwtext.client.widgets.Viewport;
+/**
+ * Entry point classes define <code>onModuleLoad()</code>.
+ */
+public class cel2 implements EntryPoint {
+        /**
+         * This is the entry point method.
+         */
+        public void onModuleLoad() {
+                  CarnetEnLigneMediateur carnetEnLigneMediateur= CarnetEnLigneMediateur.Instance();
+                  //ImageMediateur im = ImageMediateur.Instance() ;
+                  // TODO : l'utilisation du viewport rend l'application extremement lente en mode javas
+                  RootPanel.get().add(carnetEnLigneMediateur.getPanneauPrincipalCarnetEnLigne());
+                  //new Viewport(carnetEnLigneMediateur.getPanneauPrincipalCarnetEnLigne()) ;
+                  // On appelle la gestion de l'identification
+                  // Veillez d'ailleurs a ne pas appeller de services dans les constructeurs
+                  carnetEnLigneMediateur.getEtatUtilisateur();
+        }
+}

/trunk/src/org/tela_botanica/public/tela.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

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

/trunk/src/org/tela_botanica/public/etoile_vide.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/cel2.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/etoile_curseur.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/reset.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/reset.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/failed.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/failed.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/done.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/done.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-add.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-add.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/upload-stop.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/upload-stop.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-remove.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-remove.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/check.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/check.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-uploading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/file-uploading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/upload-start.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/upload-start.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/uncheck.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/images/uncheck.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/css/Ext.ux.UploadDialog.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/css/Ext.ux.UploadDialog.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/Ext.ux.UploadDialog.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/Ext.ux.UploadDialog.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/dox/automata-protocol.jpeg
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/dox/automata-protocol.jpeg
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/dox/automata-protocol.dia
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/dox/automata-protocol.dia
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/readme.txt
New file
0,0 → 1,4
Extension Page : http://max-bazhenov.com/dev/upload-dialog-2.0/index.php
Author : Maxim Bazhenov (aka MaximGB)
v 2.0 (15.02.2008)
License : respectoware

/trunk/src/org/tela_botanica/public/js/UploadDialog/Ext.ux.UploadDialog.packed.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/Ext.ux.UploadDialog.packed.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/UploadDialog/locale/ru.utf-8.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/UploadDialog/locale/ru.utf-8.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/Timeline.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/timeline-bundle.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/api/timeline-bundle.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/scripts/l10n/en/labellers.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/api/scripts/l10n/en/labellers.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/scripts/l10n/en/timeline.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/api/scripts/l10n/en/timeline.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/timeline-api.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/timeline-bundle.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/api/timeline-bundle.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/api/util/timeline-helper.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/api/util/timeline-helper.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/plugins.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/GwtExt.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/map/mapstraction.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/map/mapstraction-geocode.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/map/mapstraction-geocode.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/map/mapstraction-route.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/map/mapstraction-route.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/src/org/tela_botanica/public/js/ext/CHANGES.txt
 New file
 ,0 → 1,300
+//==========================================
+// Ext JS Release Notes
+//==========================================
+// Release Date: February 24, 2008
+// Current Version: 2.0.1 (rev 1688)
+// Previous Version: 2.0.1 (rev 1589)
+//==========================================
+NOTE: This is primarily a release of the new Ext AIR support, along with other minor bug fixes.  Everything under the 'air' folder in SVN is new in this release.
+===== Added =====
+src/widgets/form/
+    Label
+       - New simple form label class for adding labels manually
+===== Removed =====
+none
+===== Modified =====
+src/adapter/
+    ext-base.js
+    jquery-bridge.js
+    prototype-bridge.js
+       - Changed instanceOf Array check to Ext.isArray
+src/core
+    CompositeElement
+       - Changed instanceOf Array check to Ext.isArray
+    DomHelper
+       - Internal refactoring and doc updates to support efficient creation of document fragments based on an array of specification objects
+    Element
+       - Changed instanceOf Array check to Ext.isArray
+       - Doc updates
+    Ext
+       - Added isSafari2, isSafari3 and isAir properties
+       - Changed the extend function to support supplying a custom constructor when extending a class via the constructor config
+       - Added isArray and isDate functions
+       - Changed instanceOf Array check to Ext.isArray
+       - Changes in destroy to call destroy recursively before removing the listeners and element
+       - Fix in removeNode to not remove the body node (e.g., when destroying a Viewport)
+    Template
+       - Changed instanceOf Array check to Ext.isArray
+src/data/
+    ArrayReader
+       - Fix in readRecords to pass second param of full data to convert() function
+    DataField
+       - Changed instanceOf Date check to Ext.isDate
+    DataReader
+       - Changed instanceOf Array check to Ext.isArray
+    JsonReader
+       - Fix in readRecords to pass second param of full data to convert() function
+    Record
+       - Added isModified function
+       - Doc updates
+    SortTypes
+       - Changed instanceOf Date check to Ext.isDate
+    Tree
+       - Changed instanceOf Array check to Ext.isArray
+    XmlReader
+       - Fix in readRecords to pass second param of full data to convert() function
+src/dd/
+    ScrollManager
+       - Changed instanceOf Array check to Ext.isArray
+src/locale/
+    Czech (-cs)
+    German (-de)
+    Hungarian (-hu)
+    Portuguese/Brazil (-pt_BR)
+    Portuguese/European (-pt)
+    Spanish/Latin American (-es)
+    Turkish (-tr)
+       - Various updates
+    Norwegian (-no)
+       - Split into 2 files, Bokmål (-no-NB) and Nynorsk (-no-NN)
+src/state/
+    Provider
+       - Changed instanceOf Date/Array check to Ext.isDate/isArray
+src/util/
+    CSS
+       - Changed instanceOf Array check to Ext.isArray
+    Date
+       - Internal fixes
+    Format
+       - Changed instanceOf Date check to Ext.isDate
+    JSON
+       - Changed instanceOf Date/Array check to Ext.isDate/isArray
+    KeyMap
+       - Changed instanceOf Array check to Ext.isArray
+    MixedCollection
+       - Changed instanceOf Array check to Ext.isArray
+    Observable
+       - Doc updates only
+    XTemplate
+       - Changed instanceOf Array check to Ext.isArray
+src/widgets/
+    Action
+       - Added an execute function to execute the action manually using the default handler
+    BoxComponent
+       - Doc updates
+    Button
+       - Added ownerCt property
+       - Hid autoEl config since it does not apply
+    ColorPalette
+       - Changed render logic to use the existing template (this.tpl) if specified
+       - Hid autoEl config since it does not apply
+    Component
+       - Changed instanceOf Array check to Ext.isArray
+       - Added autoEl docs
+       - Fix to apply the component id to the rendered element if needed when autoEl is used
+       - Added findParentBy and findParentByType functions
+    Container
+       - Changed instanceOf Array check to Ext.isArray
+       - Changed doLayout to support an optional shallow argument to support recalculating layout only for the current container, not all subcontainers
+    CycleButton
+       - Internal refactoring
+       - Added forceIcon config
+    DataView
+       - Changed instanceOf Array check to Ext.isArray
+    DatePicker
+       - Hid autoEl config since it does not apply
+    DomQuery
+       - Changed instanceOf Array check to Ext.isArray
+    Editor
+       - Added logic to set inEditor=true (internal property) on bound fields
+       - Internal refactoring
+    LoadMask
+       - Added docs to show and hide so they will show as public
+       - Other doc updates
+    MessageBox
+       - Fixed issue of window adding a new internal 'show' handler to manage its keymap each time the window is shown (added single:true)
+    Panel
+       - Added print tool
+       - Changed instanceOf Array check to Ext.isArray
+       - Change to set ownerCt property on buttons added to the panel
+       - Hid autoEl config since it does not apply
+    TabPanel
+       - Added support for item.tabCls to apply a custom class to tabs
+       - Internal Air-specific fixes in autoScrollTabs
+       - Added additional @hides for configs that do not apply
+    Toolbar
+       - Changed instanceOf Array check to Ext.isArray
+       - Hid autoEl config since it does not apply
+       - Doc updates
+src/widgets/form/
+    BasicForm
+       - Added standardSubmit config to support standard (non-Ajax) form submissions
+       - Changed instanceOf Array check to Ext.isArray
+    Combo
+       - Changed logic to restrict the combo height to the viewport based on the optimal available space above or below the combo, also taking scroll position into account
+       - Added minHeight config to control minimum height based on new height restriction logic
+    DateField
+       - Added non-0-padded formats to the default altFormats config
+       - Changed instanceOf Date check to Ext.isDate
+    Field
+       - Fix to adjust width properly when fields are in an editor
+       - Added additional @hides for configs that do not apply
+    FieldSet
+       - Changed render logic to only output the legend element if a title, header or checkbox is specified
+    FormPanel
+       - Doc updates only
+    HtmlEditor
+       - Added Air/Safari3 support for font sizing
+       - Added additional @hides for configs that do not apply
+    Radio
+       - Added setValue override to support checking a sibling Radio of the same name whose value is the value specified (if a string value is passed)
+src/widgets/grid/
+    ColumnModel
+       - Added support for passing the standard cm config as a 'columns' property on the config object to support additional config properties that will get applied to the column model
+       - Added menuDisabled config and isMenuDisabled property function
+    CheckboxSelectionModel
+       - Added menuDisabled:true to disable the header menu by default
+    EditorGrid
+       - Change to not enter edit mode on right-click
+       - Fixes to pre/postEditValue to encode only if the value is a string type
+    GridPanel
+       - Added docs to clarify that autoWidth is not supported
+       - Changed instanceOf Array check to Ext.isArray
+       - Added config hideHeaders (used in GridView)
+       - Doc updates
+    GridView
+       - Added support for GridPanel hideHeaders config
+       - Added column resize cursor for Air
+       - Internal bug fixes
+    GroupingView
+       - Change to getGroupId to encode the value when generating the groupd id
+    PropertyGrid
+       - Changed instanceOf Date check to Ext.isDate
+       - Added menuDisabled:true to disable the header menus by default
+    RowNumberer
+       - Added menuDisabled:true to disable the header menu by default
+    RowSelectionModel
+       - Added config moveEditorOnEnter to control moving the editor to the next cell on enter
+       - Changed selectNext and selectPrevious to return boolean instead of void
+src/widgets/layout/
+    AbsoluteLayout
+       - Added AnchorLayout overrides for absolute positioing form elements when specifying position:'absolute' on a FormPanel
+    BorderLayout
+       - Changed this.collapsedEl so that it now gets an id of the panel's id + '-xcollapsed'
+       - Changed this.splitEl so that it now gets an id of the panel's id + '-xsplit'
+    FormLayout
+       - Added check to adjust anchor width for labels only if the anchored component is a form field
+    TableLayout
+       - Refactored layout logic to reduce code and fix cell spanning bugs
+src/widgets/menu/
+    Item
+       - Menu item will now use itemText if available, or text by default
+    Menu
+       - Changed instanceOf Array check to Ext.isArray
+       - Added check to use an existing keyNav on render if specified
+src/widgets/tips/
+    QuickTip
+      - Changed instanceOf Array check to Ext.isArray
+src/widgets/tree/
+    TreeDropZone
+       - Changed onNodeDrop to return a status value instead of false after a canceled drop to allow passing custom status
+       - Changed instanceOf Array check to Ext.isArray
+    TreeEditor
+       - Changes to avoid entering auto-edit mode on node double-click
+    TreeEventModel
+       - Changes to only monitor mouseover and mouseout if trackMouseOver=true
+       - Added support for tracking mouseover and mouseout on the tree node icon separately from the rest of the node
+    TreePanel
+       - Added config useArrows for Vista-style arrow support
+       - Doc updates
+    TreeSorter
+       - Added logic to re-sort automatically on text change

/trunk/src/org/tela_botanica/public/js/ext/resources/legacy/grid.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/legacy/grid.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/legacy/basic-dialog.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/legacy/basic-dialog.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/s.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/s.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/large-loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/large-loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/warning.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/warning.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/loading-balls.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/loading-balls.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/calendar.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/calendar.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/left-btn.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/left-btn.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/right-btn.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/right-btn.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/glass-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/glass-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/hd-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/hd-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/blue-loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shared/blue-loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-info.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-info.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-corners.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-corners.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/top-bottom.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/top-bottom.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-corners.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-corners.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-right.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-right.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/right-corners.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/right-corners.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/top-bottom.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/top-bottom.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-right.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/left-right.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/right-corners.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/right-corners.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-warning.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-warning.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-question.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-question.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-error.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/window/icon-error.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/button/btn-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/button/btn-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/button/btn-arrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/button/btn-arrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/tip-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/tip-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/qtip/close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/expand.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/expand.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/ns-collapse.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/ns-collapse.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/gradient-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/gradient-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/tab-close-on.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/tab-close-on.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-left.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-left.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/stuck.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/stuck.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-top.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-top.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/ns-expand.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/ns-expand.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/collapse.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/collapse.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-title-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-title-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/mini-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-title-light-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/panel-title-light-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/tab-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/tab-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/stick.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/layout/stick.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow-lr.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow-lr.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-unlock.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-unlock.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-first-disabled.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-first-disabled.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-last.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-last.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/group-expand-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/group-expand-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-asc.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-asc.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-over.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-over.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/col-move-top.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/col-move-top.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/Thumbs.db
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/Thumbs.db
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/footer-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/footer-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/done.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/done.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-prev.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-prev.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-check-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-check-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-special-col-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-special-col-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-sel.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-sel.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-prev-disabled.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-prev-disabled.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hrow-over.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hrow-over.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/refresh.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/refresh.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/arrow-left-white.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/arrow-left-white.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-first.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-first.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-vista-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-vista-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-hrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-hrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-blue-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-blue-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-blue-split.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-blue-split.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/group-by.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/group-by.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/wait.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/wait.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-special-col-sel-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-special-col-sel-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/sort_asc.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/sort_asc.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-split.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid-split.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/drop-no.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/drop-no.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/columns.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/columns.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-lock.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-lock.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-last-disabled.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-last-disabled.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hd-btn.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hd-btn.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/arrow-right-white.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/arrow-right-white.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/col-move-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/col-move-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-unlock.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-unlock.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/grid3-hrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/sort_desc.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/sort_desc.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/mso-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/mso-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hd-pop.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hd-pop.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-desc.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-desc.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-next.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-next.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-expand-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/row-expand-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/dirty.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/dirty.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/invalid_line.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/invalid_line.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-next-disabled.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/page-next-disabled.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/pick-button.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/pick-button.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/nowait.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/nowait.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-lock.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/hmenu-lock.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/drop-yes.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/grid/drop-yes.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/editor/tb-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/editor/tb-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-add.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-add.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-no.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-no.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-yes.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/dd/drop-yes.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/gradient-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/gradient-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/tb-blue.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/tb-blue.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/corners.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/corners.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/l.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/l.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/corners-blue.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/corners-blue.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/l-blue.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/l-blue.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/r.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/r.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/tb.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/tb.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/r-blue.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/box/r-blue.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow-c.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/shadow-c.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-inactive-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-inactive-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroll-left.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroll-left.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-inactive-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-inactive-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-btm-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroll-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroll-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-bg.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-bg.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroller-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/scroller-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-btm-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tab-strip-btm-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tabs-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tabs/tabs-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/ne-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/ne-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/s-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/s-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/ne-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/ne-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/s-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/s-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/e-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/e-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/nw-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/nw-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/e-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/e-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/nw-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/nw-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/se-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/se-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/se-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/se-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/square.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/square.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/sw-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/sw-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/sw-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/sizer/sw-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-plus.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-plus.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-add.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-add.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-between.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-between.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-plus.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-plus.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-line.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-line.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-plus-nl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-plus-nl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-minus.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-minus.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-yes.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-yes.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/s.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/s.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-plus-nl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-plus-nl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-minus.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-minus.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/leaf.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/leaf.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-minus-nl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-minus-nl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/folder-open.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/folder-open.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/folder.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/folder.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-minus-nl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end-minus-nl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/elbow-end.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/loading.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/loading.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/arrows.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/arrows.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-over.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-over.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-no.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-no.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-under.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/tree/drop-under.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/top-bottom.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/top-bottom.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-left-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-left-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tool-sprites.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tool-sprites.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/top-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/top-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/left-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/left-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tools-sprites-trans.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tools-sprites-trans.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-corners-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-corners-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tool-sprite-tpl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/tool-sprite-tpl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/corners-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/corners-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/light-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/light-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-top-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/panel/white-top-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/gray-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/gray-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/tb-btn-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/tb-btn-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-arrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-arrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/tb-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/tb-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-arrow-light.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-arrow-light.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-over-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/toolbar/btn-over-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/date-trigger.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/date-trigger.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/date-trigger.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/date-trigger.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger-tpl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger-tpl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/exclamation.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/exclamation.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/trigger.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/search-trigger.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/search-trigger.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/clear-trigger.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/clear-trigger.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/search-trigger.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/search-trigger.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/clear-trigger.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/clear-trigger.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/text-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/text-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/error-tip-corners.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/form/error-tip-corners.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/group-checked.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/group-checked.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/menu.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/menu.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/checked.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/checked.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/item-over.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/item-over.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/unchecked.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/unchecked.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/menu-parent.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/menu/menu-parent.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/progress/progress-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/default/progress/progress-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/toolbar/gray-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/toolbar/gray-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/toolbar/tb-btn-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/toolbar/tb-btn-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/grid/grid-split.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/grid/grid-split.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/grid/grid-vista-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/grid/grid-vista-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/s.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/s.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/gradient-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/gradient-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-inactive-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-inactive-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-inactive-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-inactive-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-btm-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/tabs/tab-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/ne-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/ne-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/s-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/s-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/ne-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/ne-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/s-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/s-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/e-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/e-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/nw-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/nw-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/e-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/e-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/nw-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/nw-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/se-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/se-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/se-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/se-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/sw-handle-dark.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/sw-handle-dark.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/sw-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/sizer/sw-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/ns-expand.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/ns-expand.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/stick.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/stick.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/expand.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/expand.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/ns-collapse.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/ns-collapse.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/collapse.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/collapse.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/gradient-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/gradient-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/tab-close-on.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/tab-close-on.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-title-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-title-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-title-light-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/panel-title-light-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/tab-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/layout/tab-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/qtip/bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/qtip/bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/qtip/tip-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/qtip/tip-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/collapse.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/collapse.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-center.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-center.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/s-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/s-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/dlg-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/dlg-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/e-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/e-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/expand.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/expand.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/hd-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/hd-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/w-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/w-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-left.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/bg-left.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/se-handle.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/vista/basic-dialog/se-handle.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/button/btn-arrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/button/btn-arrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/button/btn-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/button/btn-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/tip-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/qtip/tip-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/left-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/left-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tools-sprites-trans.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tools-sprites-trans.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-corners-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-corners-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tool-sprite-tpl.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tool-sprite-tpl.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/corners-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/corners-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/light-hd.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/light-hd.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-top-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-top-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/top-bottom.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/top-bottom.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-left-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/white-left-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tool-sprites.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/tool-sprites.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/top-bottom.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/panel/top-bottom.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-arrow.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-arrow.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/tb-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/tb-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-arrow-light.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-arrow-light.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-over-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/btn-over-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/gray-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/gray-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/tb-btn-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/toolbar/tb-btn-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/s.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/s.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/gradient-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/gradient-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-info.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-info.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-corners.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-corners.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-corners.pspimage
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-corners.pspimage
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/top-bottom.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/top-bottom.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-right.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/left-right.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/right-corners.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/right-corners.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-warning.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-warning.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-question.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-question.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-error.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/window/icon-error.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-inactive-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-inactive-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-left-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-left-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroll-left.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroll-left.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-inactive-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-inactive-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-right-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-btm-right-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroll-right.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroll-right.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-close.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-close.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-bg.png
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-bg.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroller-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/scroller-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-btm-bg.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tab-strip-btm-bg.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tabs-sprite.gif
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/images/gray/tabs/tabs-sprite.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/resources.jsb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/resources.jsb
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/window.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/window.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/button.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/button.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/layout.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/layout.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/resizable.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/resizable.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/reset.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/reset.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/README.txt
New file
0,0 → 1,3
2006-11-21 jvs:
ext-all.css contains all of the other css files combined and stripped of comments (except themes).

/trunk/src/org/tela_botanica/public/js/ext/resources/css/grid.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/grid.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/editor.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/editor.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/debug.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/debug.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/dd.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/dd.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/box.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/box.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/core.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/core.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/date-picker.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/date-picker.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/tabs.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/tabs.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/xtheme-gray.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/xtheme-gray.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/tree.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/tree.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/panel.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/panel.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/combo.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/combo.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/dialog.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/dialog.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/qtips.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/qtips.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/borders.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/borders.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/toolbar.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/toolbar.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/reset-min.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/reset-min.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/form.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/form.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/progress.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/progress.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/menu.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/menu.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/css/ext-all.css
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/css/ext-all.css
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/resources/raw-images/shadow.psd
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/resources/raw-images/shadow.psd
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/src/org/tela_botanica/public/js/ext/resources/license.txt
 New file
 ,0 → 1,50
+Ext JS - JavaScript Library
+Copyright (c) 2006-2008, Ext JS, LLC
+All rights reserved.
+licensing@extjs.com
+http://extjs.com/license
+License of CSS and Graphics ("Assets")
+------------------------------------------------------------------------------------------
+The Assets distributed with Ext are licensed for use ONLY
+with their associated Ext JavaScript component ("Component"). Use of the Assets in
+any way that does not also include the Component is prohibited without explicit
+permission from Ext JS, LLC.  Deriving images and CSS from the Assets in an effort
+to bypass this license is also prohibited.
+Open Source License
+------------------------------------------------------------------------------------------
+Ext is also licensed under the terms of the Open Source LGPL 3.0 license. You may use
+our open source license if you:
+ * Want to use Ext in an open source project that precludes using non-open source software
+ * Plan to use Ext in a personal, educational or non-profit manner
+ * Are using Ext in a commercial application that is not a software development library
+or toolkit, you will meet LGPL requirements and you do not wish to support the project
+http://www.gnu.org/licenses/lgpl.html
+Commercial License
+------------------------------------------------------------------------------------------
+If you are using this library for commercial purposes, we encourage you to purchase
+a commercial license. Please visit http://extjs.com/license for more details.
+OEM / Reseller License
+------------------------------------------------------------------------------------------
+If you plan to distribute Ext in a product that will be packaged or sold as a software
+development library, toolkit or plug-in-based framework ("LIBRARY"), we require that you
+work with us to establish a specific license that is appropriate. Use of the open source
+license in a LIBRARY is not permitted without explicit permission from Ext JS, LLC.
+For more details, please visit: http://extjs.com/license.
+--
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.

 /trunk/src/org/tela_botanica/public/js/ext/INCLUDE_ORDER.txt
 New file
 ,0 → 1,35
+All adapter related files below are located in
+/adapters/<lib name>/ of this zip file.
+Your include order should be:
+Ext Stand-alone
+-------------------------------------------------------------------
+ext-base.js
+ext-all.js (or your choice of files)
+Yahoo! UI (.12+)
+-------------------------------------------------------------------
+yui-utilities.js
+ext-yui-adapter.js
+ext-all.js (or your choice of files)
+jQuery (1.1+)
+-------------------------------------------------------------------
+jquery.js
+ext-jquery-adapter.js
+ext-all.js (or your choice of files)
+Prototype (1.5+) / Scriptaculous (1.7+)
+-------------------------------------------------------------------
+prototype.js
+scriptaculous.js?load=effects  (or whatever you want to load)
+ext-prototype-adapter.js
+ext-all.js (or your choice of files)
+See the examples folders for more examples.

/trunk/src/org/tela_botanica/public/js/ext/build/util/MixedCollection-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/MixedCollection-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/XTemplate-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/XTemplate-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/Observable-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/Observable-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/KeyMap-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/KeyMap-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/CSS-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/CSS-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/Format-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/Format-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/TaskMgr-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/TaskMgr-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/JSON-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/JSON-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/DelayedTask-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/DelayedTask-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/TextMetrics-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/TextMetrics-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/ClickRepeater-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/ClickRepeater-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/Date-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/Date-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/util/KeyNav-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/util/KeyNav-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pt_BR.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pt_BR.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-no_NN.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-no_NN.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-gr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-gr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-hr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-hr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-nl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-nl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fr_CA.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fr_CA.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-th.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-th.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-it.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-it.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sv_SE.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sv_SE.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-lt.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-lt.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-lv.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-lv.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ca.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ca.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pt.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-pt.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-vn.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-vn.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-da.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-da.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-tr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-tr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fa.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-fa.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-bg.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-bg.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-de.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-de.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-el_GR.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-el_GR.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sr_RS.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sr_RS.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ja.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ja.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-he.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-he.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-cs.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-cs.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-mk.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-mk.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-es.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-es.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ko.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ko.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-hu.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-hu.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sk.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-sk.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ro.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ro.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ru.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ru.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-af.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-af.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-no_NB.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-no_NB.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-zh_TW.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-zh_TW.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-id.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-id.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-en_UK.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-en_UK.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ukr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-ukr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-zh_CN.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-zh_CN.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-en.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/locale/ext-lang-en.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/ext-base-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/ext-base-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/jquery-bridge-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/jquery-bridge-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/prototype-bridge-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/prototype-bridge-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/yui-bridge-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/adapter/yui-bridge-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/state/CookieProvider-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/state/CookieProvider-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/state/Provider-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/state/Provider-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/state/StateManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/state/StateManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/debug-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/debug-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/MasterTemplate-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/MasterTemplate-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/View-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/View-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/BasicDialog-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/BasicDialog-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutStateManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutStateManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BorderLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BorderLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/ContentPanels-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/ContentPanels-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/SplitLayoutRegion-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/SplitLayoutRegion-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/ReaderLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/ReaderLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutRegion-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/LayoutRegion-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BorderLayoutRegions-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BorderLayoutRegions-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BasicLayoutRegion-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/layout/BasicLayoutRegion-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/GridView2-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/GridView2-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/AbstractGridView-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/AbstractGridView-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/JsonView-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/legacy/JsonView-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/DataView-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/DataView-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/NumberField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/NumberField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Radio-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Radio-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/FieldSet-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/FieldSet-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Combo-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Combo-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TimeField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TimeField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Form-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Form-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/BasicForm-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/BasicForm-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TriggerField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TriggerField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/HtmlEditor-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/HtmlEditor-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Action-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Action-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TextArea-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TextArea-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Label-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Label-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/DateField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/DateField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Field-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Field-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Checkbox-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Checkbox-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TextField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/TextField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/VTypes-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/VTypes-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Hidden-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/form/Hidden-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ComponentMgr-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ComponentMgr-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Button-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Button-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/DatePicker-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/DatePicker-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Layer-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Layer-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Action-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Action-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Resizable-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Resizable-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Container-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Container-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/QuickTip-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/QuickTip-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/ToolTip-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/ToolTip-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/QuickTips-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/QuickTips-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/Tip-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tips/Tip-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/TabPanel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/TabPanel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Editor-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Editor-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/PagingToolbar-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/PagingToolbar-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ProgressBar-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ProgressBar-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/CycleButton-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/CycleButton-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/LoadMask-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/LoadMask-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ColorPalette-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/ColorPalette-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Panel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Panel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/WindowManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/WindowManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Toolbar-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Toolbar-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Component-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Component-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeFilter-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeFilter-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeNode-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeNode-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeEditor-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeEditor-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeLoader-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeLoader-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeSelectionModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeSelectionModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeDragZone-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeDragZone-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeSorter-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeSorter-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreePanel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreePanel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeDropZone-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeDropZone-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeEventModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeEventModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/AsyncTreeNode-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/AsyncTreeNode-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeNodeUI-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/tree/TreeNodeUI-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Window-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Window-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/PanelDD-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/PanelDD-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/ColorItem-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/ColorItem-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Item-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Item-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Adapter-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Adapter-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Separator-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Separator-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/DateMenu-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/DateMenu-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/ColorMenu-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/ColorMenu-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/TextItem-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/TextItem-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Menu-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/Menu-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/BaseItem-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/BaseItem-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/MenuMgr-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/MenuMgr-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/CheckItem-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/CheckItem-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/DateItem-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/menu/DateItem-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/BoxComponent-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/BoxComponent-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Viewport-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Viewport-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/SplitBar-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/SplitBar-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/FormLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/FormLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/TableLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/TableLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/CardLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/CardLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AnchorLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AnchorLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/BorderLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/BorderLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/ColumnLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/ColumnLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AbsoluteLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AbsoluteLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AccordionLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/AccordionLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/ContainerLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/ContainerLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/FitLayout-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/layout/FitLayout-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Shadow-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/Shadow-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/SplitButton-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/SplitButton-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/RowNumberer-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/RowNumberer-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/AbstractSelectionModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/AbstractSelectionModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/PropertyGrid-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/PropertyGrid-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/EditorGrid-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/EditorGrid-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridEditor-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridEditor-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/CheckboxSelectionModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/CheckboxSelectionModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridDD-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridDD-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/RowSelectionModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/RowSelectionModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridView-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridView-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnSplitDD-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnSplitDD-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnDD-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/ColumnDD-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridPanel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GridPanel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GroupingView-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/GroupingView-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/CellSelectionModel-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/grid/CellSelectionModel-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/MessageBox-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/widgets/MessageBox-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/StatusProxy-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/StatusProxy-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/Registry-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/Registry-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragTracker-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragTracker-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragZone-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragZone-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/ScrollManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/ScrollManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DropTarget-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DropTarget-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragSource-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DragSource-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DDCore-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DDCore-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DropZone-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/dd/DropZone-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/Element-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/Element-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/Template-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/Template-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/CompositeElement-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/CompositeElement-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/EventManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/EventManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/Fx-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/Fx-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/UpdateManager-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/UpdateManager-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/DomHelper-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/DomHelper-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/Ext-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/Ext-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/core/DomQuery-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/core/DomQuery-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/XmlReader-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/XmlReader-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/JsonStore-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/JsonStore-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataReader-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataReader-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/JsonReader-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/JsonReader-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/Store-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/Store-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/Tree-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/Tree-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/Connection-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/Connection-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/ArrayReader-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/ArrayReader-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/ScriptTagProxy-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/ScriptTagProxy-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/StoreMgr-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/StoreMgr-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/SimpleStore-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/SimpleStore-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/GroupingStore-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/GroupingStore-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/MemoryProxy-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/MemoryProxy-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataProxy-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataProxy-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/SortTypes-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/SortTypes-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataField-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/DataField-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/Record-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/Record-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/build/data/HttpProxy-min.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/build/data/HttpProxy-min.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/src/org/tela_botanica/public/js/ext/LICENSE.txt
 New file
 ,0 → 1,50
+Ext JS - JavaScript Library
+Copyright (c) 2006-2007, Ext JS, LLC
+All rights reserved.
+licensing@extjs.com
+http://extjs.com/license
+License of CSS and Graphics ("Assets")
+------------------------------------------------------------------------------------------
+The Assets distributed with Ext are licensed for use ONLY
+with their associated Ext JavaScript component ("Component"). Use of the Assets in
+any way that does not also include the Component is prohibited without explicit
+permission from Ext JS, LLC.  Deriving images and CSS from the Assets in an effort
+to bypass this license is also prohibited.
+Open Source License
+------------------------------------------------------------------------------------------
+Ext is also licensed under the terms of the Open Source LGPL 3.0 license. You may use
+our open source license if you:
+ * Want to use Ext in an open source project that precludes using non-open source software
+ * Plan to use Ext in a personal, educational or non-profit manner
+ * Are using Ext in a commercial application that is not a software development library
+or toolkit, you will meet LGPL requirements and you do not wish to support the project
+http://www.gnu.org/licenses/lgpl.html
+Commercial License
+------------------------------------------------------------------------------------------
+If you are using this library for commercial purposes, we encourage you to purchase
+a commercial license. Please visit http://extjs.com/license for more details.
+OEM / Reseller License
+------------------------------------------------------------------------------------------
+If you plan to distribute Ext in a product that will be packaged or sold as a software
+development library, toolkit or plug-in-based framework ("LIBRARY"), we require that you
+work with us to establish a specific license that is appropriate. Use of the open source
+license in a LIBRARY is not permitted without explicit permission from Ext JS, LLC.
+For more details, please visit: http://extjs.com/license.
+--
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.

/trunk/src/org/tela_botanica/public/js/ext/adapter/jquery/ext-jquery-adapter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/jquery/ext-jquery-adapter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/jquery/jquery.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/jquery/jquery.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/ext/ext-base.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/ext/ext-base.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/effects.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/effects.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/scriptaculous.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/scriptaculous.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/ext-prototype-adapter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/ext-prototype-adapter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/prototype.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/prototype/prototype.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/yui/yui-utilities.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/yui/yui-utilities.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/adapter/yui/ext-yui-adapter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/adapter/yui/ext-yui-adapter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/ext.jsb
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/MixedCollection.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/MixedCollection.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/XTemplate.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/XTemplate.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/Observable.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/Observable.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/KeyMap.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/KeyMap.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/CSS.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/CSS.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/Format.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/Format.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/TaskMgr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/TaskMgr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/JSON.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/JSON.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/DelayedTask.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/DelayedTask.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/TextMetrics.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/TextMetrics.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/ClickRepeater.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/ClickRepeater.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/Date.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/Date.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/util/KeyNav.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/util/KeyNav.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-en.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-en.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-gr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-gr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-hr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-hr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-nl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-nl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-th.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-th.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-it.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-it.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sl.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sl.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-lt.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-lt.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-lv.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-lv.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ca.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ca.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pt.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pt.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-vn.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-vn.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-da.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-da.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-tr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-tr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fa.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fa.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-bg.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-bg.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-de.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-de.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ja.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ja.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-no_NB.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-no_NB.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-zh_TW.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-zh_TW.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-he.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-he.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-en_UK.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-en_UK.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ukr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ukr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-zh_CN.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-zh_CN.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-cs.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-cs.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pt_BR.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-pt_BR.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-no_NN.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-no_NN.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-mk.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-mk.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-es.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-es.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ko.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ko.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fr_CA.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-fr_CA.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-hu.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-hu.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sk.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sk.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sv_SE.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sv_SE.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ro.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ro.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ru.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-ru.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-af.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-af.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-el_GR.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-el_GR.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sr_RS.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-sr_RS.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-id.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/locale/ext-lang-id.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/ext-base.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/ext-base.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/jquery-bridge.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/jquery-bridge.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/prototype-bridge.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/prototype-bridge.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/yui-bridge.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/adapter/yui-bridge.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/src/org/tela_botanica/public/js/ext/source/license.txt
 New file
 ,0 → 1,50
+Ext JS - JavaScript Library
+Copyright (c) 2006-2008, Ext JS, LLC
+All rights reserved.
+licensing@extjs.com
+http://extjs.com/license
+License of CSS and Graphics ("Assets")
+------------------------------------------------------------------------------------------
+The Assets distributed with Ext are licensed for use ONLY
+with their associated Ext JavaScript component ("Component"). Use of the Assets in
+any way that does not also include the Component is prohibited without explicit
+permission from Ext JS, LLC.  Deriving images and CSS from the Assets in an effort
+to bypass this license is also prohibited.
+Open Source License
+------------------------------------------------------------------------------------------
+Ext is also licensed under the terms of the Open Source LGPL 3.0 license. You may use
+our open source license if you:
+ * Want to use Ext in an open source project that precludes using non-open source software
+ * Plan to use Ext in a personal, educational or non-profit manner
+ * Are using Ext in a commercial application that is not a software development library
+or toolkit, you will meet LGPL requirements and you do not wish to support the project
+http://www.gnu.org/licenses/lgpl.html
+Commercial License
+------------------------------------------------------------------------------------------
+If you are using this library for commercial purposes, we encourage you to purchase
+a commercial license. Please visit http://extjs.com/license for more details.
+OEM / Reseller License
+------------------------------------------------------------------------------------------
+If you plan to distribute Ext in a product that will be packaged or sold as a software
+development library, toolkit or plug-in-based framework ("LIBRARY"), we require that you
+work with us to establish a specific license that is appropriate. Use of the open source
+license in a LIBRARY is not permitted without explicit permission from Ext JS, LLC.
+For more details, please visit: http://extjs.com/license.
+--
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.

/trunk/src/org/tela_botanica/public/js/ext/source/state/StateManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/state/StateManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/state/CookieProvider.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/state/CookieProvider.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/state/Provider.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/state/Provider.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/debug.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/View.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/View.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/BasicDialog.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/BasicDialog.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/GridView2.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/GridView2.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutStateManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutStateManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BorderLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BorderLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/ContentPanels.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/ContentPanels.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/SplitLayoutRegion.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/SplitLayoutRegion.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/ReaderLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/ReaderLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutRegion.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/LayoutRegion.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BorderLayoutRegions.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BorderLayoutRegions.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BasicLayoutRegion.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/layout/BasicLayoutRegion.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/AbstractGridView.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/AbstractGridView.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/JsonView.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/JsonView.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/MasterTemplate.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/legacy/MasterTemplate.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/ContainerLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/ContainerLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/FitLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/FitLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/FormLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/FormLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/TableLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/TableLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/CardLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/CardLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AnchorLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AnchorLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/BorderLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/BorderLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/ColumnLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/ColumnLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AbsoluteLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AbsoluteLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AccordionLayout.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/layout/AccordionLayout.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Window.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Window.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnSplitDD.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnSplitDD.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnDD.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnDD.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridPanel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridPanel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GroupingView.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GroupingView.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/CellSelectionModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/CellSelectionModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/RowNumberer.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/RowNumberer.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/AbstractSelectionModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/AbstractSelectionModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/PropertyGrid.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/PropertyGrid.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/EditorGrid.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/EditorGrid.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridEditor.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridEditor.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/CheckboxSelectionModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/CheckboxSelectionModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridDD.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridDD.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/ColumnModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/RowSelectionModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/RowSelectionModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridView.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/grid/GridView.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/BoxComponent.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/BoxComponent.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Layer.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Layer.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Viewport.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Viewport.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Resizable.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Resizable.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/SplitBar.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/SplitBar.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Container.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Container.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Shadow.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Shadow.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/PagingToolbar.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/PagingToolbar.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Action.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Action.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TextArea.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TextArea.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Label.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Label.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/DateField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/DateField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Field.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Field.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Checkbox.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Checkbox.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TextField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TextField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/VTypes.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/VTypes.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Hidden.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Hidden.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/NumberField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/NumberField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Radio.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Radio.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Combo.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Combo.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/FieldSet.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/FieldSet.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TimeField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TimeField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Form.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/Form.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/BasicForm.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/BasicForm.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TriggerField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/TriggerField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/HtmlEditor.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/form/HtmlEditor.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ProgressBar.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ProgressBar.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/CycleButton.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/CycleButton.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/MessageBox.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/MessageBox.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Panel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Panel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Toolbar.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Toolbar.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/WindowManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/WindowManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Component.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Component.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/QuickTip.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/QuickTip.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/ToolTip.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/ToolTip.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/QuickTips.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/QuickTips.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/Tip.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tips/Tip.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/DataView.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/DataView.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/PanelDD.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/PanelDD.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ComponentMgr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ComponentMgr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/DatePicker.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/DatePicker.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Button.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Button.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Action.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Action.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeSorter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeSorter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreePanel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreePanel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeDropZone.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeDropZone.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeEventModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeEventModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/AsyncTreeNode.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/AsyncTreeNode.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeNodeUI.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeNodeUI.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeFilter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeFilter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeNode.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeNode.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeEditor.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeEditor.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeLoader.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeLoader.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeSelectionModel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeSelectionModel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeDragZone.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/tree/TreeDragZone.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Editor.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/Editor.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/TabPanel.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/TabPanel.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/SplitButton.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/SplitButton.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/MenuMgr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/MenuMgr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/CheckItem.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/CheckItem.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/DateItem.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/DateItem.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/ColorItem.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/ColorItem.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Item.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Item.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Adapter.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Adapter.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Separator.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Separator.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/DateMenu.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/DateMenu.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/ColorMenu.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/ColorMenu.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/TextItem.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/TextItem.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Menu.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/Menu.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/BaseItem.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/menu/BaseItem.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/LoadMask.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/LoadMask.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ColorPalette.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/widgets/ColorPalette.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragSource.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragSource.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DDCore.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DDCore.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DropZone.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DropZone.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/StatusProxy.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/StatusProxy.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/Registry.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/Registry.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragTracker.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragTracker.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragZone.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DragZone.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/ScrollManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/ScrollManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DropTarget.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/dd/DropTarget.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/Element.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/Element.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/Template.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/Template.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/CompositeElement.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/CompositeElement.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/EventManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/EventManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/Fx.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/Fx.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/UpdateManager.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/UpdateManager.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/DomHelper.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/DomHelper.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/Ext.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/Ext.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/core/DomQuery.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/core/DomQuery.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/HttpProxy.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/HttpProxy.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/XmlReader.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/XmlReader.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/JsonStore.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/JsonStore.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataReader.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataReader.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/JsonReader.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/JsonReader.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/Store.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/Store.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/Tree.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/Tree.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/Connection.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/Connection.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/ArrayReader.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/ArrayReader.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/ScriptTagProxy.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/ScriptTagProxy.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/StoreMgr.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/StoreMgr.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/SimpleStore.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/SimpleStore.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/GroupingStore.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/GroupingStore.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/MemoryProxy.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/MemoryProxy.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataProxy.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataProxy.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/SortTypes.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/SortTypes.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataField.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/DataField.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/source/data/Record.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/source/data/Record.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/ext-all.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/ext-core.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/ext-all-debug.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/js/ext/ext-core-debug.js
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/trunk/src/org/tela_botanica/public/js/ext/ext-core-debug.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/etoile_petite.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/config.js
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/note-off.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/note-on.gif
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /trunk/src/org/tela_botanica/public/cel2.html
 New file
 ,0 → 1,42
+<!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>cel2</title>
+    <!--                                           -->
+    <!-- This script loads your compiled module.   -->
+    <!-- If you add any GWT meta tags, they must   -->
+    <!-- be added before this line.                -->
+    <!--                                           -->
+    <script type="text/javascript" language="javascript" src="config.js"></script>
+    <script type="text/javascript" language="javascript" src="org.tela_botanica.cel2.nocache.js"></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>
+  </body>
+</html>

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

/trunk/src/org/tela_botanica/public/page_prev.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/etoile_notee.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

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

/trunk/src/org/tela_botanica/public/images/vide.jpg
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/page_suiv.png
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/trunk/src/org/tela_botanica/public/vide.jpg
New file
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

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

Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev HEAD → Rev 33