| /trunk/src/org/tela_botanica/client/h |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /trunk/src/org/tela_botanica/client/h |
|---|
| New file |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /trunk/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,237 |
| 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,0 → 1,102 |
| 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,0 → 1,35 |
| 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 ; |
| /** |
| * 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/MotsClesAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,226 |
| 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/UtilisateurAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,117 |
| 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.interfaces.iRetourUtilisateur; |
| 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 { |
| /** |
| * Constructeur |
| */ |
| public UtilisateurAsynchroneDAO() { |
| } |
| /** |
| * Methode de classe d'appel du service gestion identification |
| * @param baseURL : URL du service |
| * @param retour : methode appelle en retour d'appel |
| */ |
| public void getUtilisateur(String baseURL, final iRetourUtilisateur retour) { |
| // Recherche identifiant utilisateur identifie |
| HTTPRequest.asyncGet(baseURL + "/User/", new ResponseTextHandler() { |
| public void onCompletion(String str) { |
| JSONValue jsonValue = JSONParser.parse(str); |
| 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 |
| retour.onRetour(new Utilisateur(identifiant, identifie)); |
| } |
| } |
| }); |
| } |
| public void deconnecterUtilisateur(String baseURL, final iRetourUtilisateur retour, String user) { |
| HTTPRequest.asyncGet(baseURL + "/User/" + user , |
| new ResponseTextHandler() { |
| public void onCompletion(String str) { |
| JSONValue jsonValue = JSONParser.parse(str); |
| 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 |
| retour.onRetour(new Utilisateur(identifiant, identifie)); |
| } |
| } |
| }); |
| } |
| public void connecteUtilisateur(String baseURL,final iRetourUtilisateur retour, String login, String password) { |
| HTTPRequest.asyncGet(baseURL + "/User/" + login + "/" + password , |
| new ResponseTextHandler() { |
| public void onCompletion(String str) { |
| JSONValue jsonValue = JSONParser.parse(str); |
| 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 |
| retour.onRetour(new Utilisateur(identifiant, identifie)); |
| } |
| } |
| }); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/ObservationAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,112 |
| 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.Util; |
| import org.tela_botanica.client.interfaces.iRetourObservation; |
| import com.google.gwt.http.client.URL; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONNumber; |
| 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 ObservationAsynchroneDAO { |
| /** |
| * Constructeur |
| */ |
| public ObservationAsynchroneDAO() { |
| } |
| public void getNombreObservation(String baseURL, final iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre) { |
| HTTPRequest.asyncGet(baseURL + "/InventoryItemList/" + identifiant + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) + "/" + annee + "/" + mois + "/" + jour + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit), |
| new ResponseTextHandler() { |
| public void onCompletion(String str) { |
| JSONValue jsonValue = JSONParser.parse(str); |
| JSONNumber jsonNumber; |
| if ((jsonNumber = jsonValue.isNumber()) != null) { |
| retour.onRetour(new Observation((int) jsonNumber.getValue())); |
| } |
| } |
| }); |
| } |
| public void getListeObservation(String baseURL,final iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur) |
| { |
| HTTPRequest.asyncGet(baseURL + "/InventoryItemList/" + identifiant + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) +"/" + annee + "/" + mois + "/" + jour + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit) + "/" |
| + debut + "/" + longueur , |
| new ResponseTextHandler() { |
| public void onCompletion(String str) { |
| JSONValue jsonValue = JSONParser.parse(str); |
| JSONArray jsonArray; |
| JSONArray jsonArrayNested; |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| if ((jsonArray = jsonValue.isArray()) != null) { |
| int arraySize = jsonArray.size(); |
| Observation[] listeObservation=new Observation[arraySize]; |
| for (int i = 0; i < arraySize; i++) { |
| if ((jsonArrayNested = jsonArray.get(i).isArray()) != null) { |
| String transmis=((JSONString) jsonArrayNested.get(13)).stringValue(); |
| String nomSaisi=Util.toCelString(((JSONString) jsonArrayNested.get(0)).toString()); |
| String nomRetenu=Util.toCelString(((JSONString) jsonArrayNested.get(2)).toString()); |
| String numeroNomenclatural=((JSONString) jsonArrayNested.get(3)).stringValue(); |
| String numeroTaxonomique=((JSONString) jsonArrayNested.get(4)).stringValue(); |
| String famille=Util.toCelString(((JSONString) jsonArrayNested .get(5)).toString()); |
| String localite=Util.toCelString(((JSONString) jsonArrayNested .get(6)).toString()); |
| String lieudit=Util.toCelString(((JSONString) jsonArrayNested .get(9)).toString()); |
| String station=Util.toCelString(((JSONString) jsonArrayNested .get(10)).toString()); |
| String milieu=Util.toCelString(((JSONString) jsonArrayNested .get(11)).toString()); |
| String commentaire=Util.toCelString(((JSONString) jsonArrayNested .get(12)).toString()); |
| String date=((JSONString) jsonArrayNested .get(8)).stringValue(); |
| String numeroOrdre=((JSONString) jsonArrayNested.get(7)).stringValue(); |
| listeObservation[i]=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclatural, numeroTaxonomique, famille, localite, lieudit, station, milieu, commentaire, date, numeroOrdre); |
| } |
| } |
| retour.onRetour(new Observation(listeObservation)); |
| } |
| } |
| } |
| }); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/Utilisateur.java |
|---|
| New file |
| 0,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/Observation.java |
|---|
| New file |
| 0,0 → 1,95 |
| package org.tela_botanica.client.modeles; |
| public class Observation { |
| private int nombreObservations=0; |
| private Observation [] listeObservation=null; |
| private String transmis=null; |
| private String nomSaisi=null; |
| private String nomRetenu=null; |
| private String numeroNomenclatural=null; |
| private String numeroTaxonomique=null; |
| private String famille=null; |
| private String localite=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() { |
| } |
| /** |
| * Constructeur nombre total d'observations |
| * @param i |
| */ |
| public Observation(int i) { |
| nombreObservations=i; |
| } |
| public int getNombreObservations() { |
| return nombreObservations; |
| } |
| /** |
| * @param transmis |
| * @param nomSaisi |
| * @param nomRetenu |
| * @param numeroNomenclatural |
| * @param numeroTaxonomique |
| * @param famille |
| * @param localite |
| * @param lieudit |
| * @param station |
| * @param milieu |
| * @param commentaire |
| * @param date |
| * @param numeroOrdre |
| */ |
| public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclatural, String numeroTaxonomique, String famille, String localite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) { |
| this.transmis = transmis; |
| this.nomSaisi = nomSaisi; |
| this.nomRetenu = nomRetenu; |
| this.numeroNomenclatural = numeroNomenclatural; |
| this.numeroTaxonomique = numeroTaxonomique; |
| this.famille = famille; |
| this.localite = localite; |
| this.lieudit = lieudit; |
| this.station = station; |
| this.milieu = milieu; |
| this.commentaire = commentaire; |
| this.date = date; |
| this.numeroOrdre = numeroOrdre; |
| } |
| public Observation(Observation[] listeObservation) { |
| this.listeObservation=listeObservation; |
| } |
| public Observation[] getListeObservation() { |
| return listeObservation; |
| } |
| public String getNomSaisi() { |
| return nomSaisi; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,173 |
| 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/ImageCarnet.java |
|---|
| New file |
| 0,0 → 1,367 |
| 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/ImageAsynchroneDAO.java |
|---|
| New file |
| 0,0 → 1,165 |
| 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/ListeImageCarnet.java |
|---|
| New file |
| 0,0 → 1,55 |
| 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/ObservationModele.java |
|---|
| New file |
| 0,0 → 1,37 |
| package org.tela_botanica.client.observation; |
| import org.tela_botanica.client.interfaces.iRetourObservation; |
| import org.tela_botanica.client.modeles.ObservationAsynchroneDAO; |
| import com.google.gwt.i18n.client.Dictionary; |
| public class ObservationModele { |
| private final String baseURL; |
| public ObservationModele() { |
| baseURL=Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
| } |
| public void getNombreObservation(final iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre) { |
| new ObservationAsynchroneDAO().getNombreObservation(baseURL, retour, identifiant, identifiantLocalite, localite, annee, mois, jour, lieudit, rechercheLibre ); |
| } |
| public void getListeObservation(iRetourObservation retour, String identifiant, String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur) { |
| new ObservationAsynchroneDAO().getListeObservation(baseURL, retour, identifiant, identifiantLocalite, localite, annee, mois, jour, lieudit, rechercheLibre, debut, longueur ); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java |
|---|
| New file |
| 0,0 → 1,256 |
| package org.tela_botanica.client.observation; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.iMediateur; |
| import org.tela_botanica.client.interfaces.iRetourObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.RootPanel; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| public class ObservationMediateur implements iMediateur{ |
| // Evenenements |
| final static public int NOMBRE_OBSERVATION=1; |
| final static public int LISTE_OBSERVATION=2; |
| private CarnetEnLigneMediateur carnetEnLigneMediateur=null; // Mediateur General |
| private final ObservationModele observationModele=new ObservationModele(); |
| private Observation observation=null; |
| // Variable interne |
| private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica"; |
| // Composants graphiques |
| private EtatConnexionVue etatConnexionVue=null; // Vue Etat de la connexion utilisateur |
| private FormulaireDeConnexionVue formulaireDeConnexionVue=null; // Formulaire de connexion utilisateur |
| private ListeObservationsVue listeObservationsVue = null; // Liste de releves |
| // |
| public ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur) { |
| this.carnetEnLigneMediateur=carnetEnLigneMediateur; |
| etatConnexionVue=new EtatConnexionVue(this); |
| listeObservationsVue=new ListeObservationsVue(this); |
| VerticalPanel panel=new VerticalPanel(); |
| panel.add(etatConnexionVue); |
| panel.add(listeObservationsVue); |
| RootPanel.get().add(panel); |
| onInitialisation(); |
| } |
| /// Methodes privees |
| /** |
| * |
| * Initialisations |
| * |
| */ |
| private void onInitialisation() { |
| afficheEtatConnexion(); |
| onFiltrageListeObservation("all","all","all"); |
| } |
| // Filtre selection lieu |
| /** |
| * Action sur selection d'un lieu : affichage de la liste des taxons correspondants au filtrage |
| */ |
| public void onFiltrageListeObservation(String id_loc, String loc,String lieu) { |
| // Positionnement Filtre affichage |
| listeObservationsVue.setIdLocation(id_loc); |
| listeObservationsVue.setLocalite(loc); |
| listeObservationsVue.setLieudit(lieu); |
| listeObservationsVue.initialiser(); |
| // Affichage des filtres |
| listeObservationsVue.displayFilter(); |
| } |
| /// UTILISATEUR |
| /** |
| * Affichage etat de la connexion |
| */ |
| private void afficheEtatConnexion() { |
| if (!carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
| etatConnexionVue.setEtat(texteDeconnexion,false); |
| } |
| else { |
| etatConnexionVue.setEtat(carnetEnLigneMediateur.getUtilisateur().getIdentifiant()+ " (deconnexion)",true); |
| } |
| } |
| /** |
| * |
| * Affichage boite de connexion |
| * |
| */ |
| public void afficherDialogueConnexion() { |
| // TODO : singleton ? |
| 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(); |
| } |
| /** |
| * Deconnexion de l'utilisateur en cours |
| */ |
| public void deconnecterUtilisateur() { |
| // carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.DECONNEXION,this); |
| carnetEnLigneMediateur.deconnecterUtilisateur(); |
| } |
| /** |
| * Tentative de connexion utilisateur |
| * @param login |
| * @param password |
| */ |
| public void connecterUtilisateur(String login, String password) { |
| // carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.CONNEXION,this); |
| carnetEnLigneMediateur.connecterUtilisateur(login, password); |
| } |
| /// OBSERVATION |
| /** |
| * Recherche nombre d'enregistrement pour l'utilisateur et la localite en cours |
| * |
| */ |
| public void getNombreObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre ) { |
| observationModele.getNombreObservation( |
| new iRetourObservation() { |
| public void onRetour(Observation obs) { |
| observation=obs; |
| //fireEvent(NOMBRE_OBSERVATION); |
| } |
| }, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre |
| ); |
| } |
| public void getListeObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur) { |
| observationModele.getListeObservation( |
| new iRetourObservation() { |
| public void onRetour(Observation obs) { |
| observation=obs; |
| //fireEvent(LISTE_OBSERVATION); |
| } |
| }, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre, debut, longueur |
| ); |
| } |
| public Observation getObservation() { |
| return observation; |
| } |
| /// EVENEMENTS |
| /** |
| * Evenements |
| * |
| */ |
| /* |
| public void handleEvent(BaseEvent be) { |
| switch (be.type) { |
| case CarnetEnLigneMediateur.DECONNEXION: |
| afficheEtatConnexion(); |
| break; |
| case CarnetEnLigneMediateur.CONNEXION: |
| if (carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
| formulaireDeConnexionVue.hide(); |
| afficheEtatConnexion(); |
| } |
| else { |
| formulaireDeConnexionVue.afficherMessageAlerte(); // Erreur identification |
| } |
| break; |
| } |
| } |
| */ |
| } |
| /trunk/src/org/tela_botanica/client/observation/EtatConnexionVue.java |
|---|
| New file |
| 0,0 → 1,107 |
| /** |
| 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.observation; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Composite; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.HorizontalPanel; |
| import com.google.gwt.user.client.ui.Widget; |
| public class EtatConnexionVue extends Composite { |
| private ObservationMediateur observationMediateur=null; |
| private HTML signLabel = new HTML() ; |
| private boolean connecte = false ; |
| public EtatConnexionVue(final ObservationMediateur med) { |
| observationMediateur=med; |
| HorizontalPanel outer = new HorizontalPanel(); |
| HorizontalPanel inner = new HorizontalPanel(); |
| outer.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT); |
| inner.add(signLabel); |
| inner.setSpacing(3); |
| outer.add(inner); |
| initWidget(outer); |
| signLabel.addClickListener( |
| new ClickListener() { |
| public void onClick(Widget sender) { |
| // Non connecte ? Lien vers boite de connection |
| if (!connecte) { |
| observationMediateur.afficherDialogueConnexion(); |
| } |
| else { |
| observationMediateur.deconnecterUtilisateur(); |
| } |
| } |
| } |
| ); |
| } |
| public void setEtat(String text, boolean connecte) { |
| signLabel.setHTML(text); |
| this.connecte=connecte; |
| } |
| } |
| /* +--Fin du code ---------------------------------------------------------------------------------------+ |
| * $Log: not supported by cvs2svn $ |
| * 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 |
| * |
| * |
| */ |
| /trunk/src/org/tela_botanica/client/observation/FormulaireDeConnexionVue.java |
|---|
| New file |
| 0,0 → 1,208 |
| /** |
| 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.observation; |
| // TODO : utiliser classe formulaire |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.DialogBox; |
| import com.google.gwt.user.client.ui.Grid; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.KeyboardListener; |
| import com.google.gwt.user.client.ui.PasswordTextBox; |
| import com.google.gwt.user.client.ui.TextBox; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| import com.google.gwt.user.client.ui.Widget; |
| public class FormulaireDeConnexionVue extends DialogBox { |
| private ObservationMediateur observationMediateur=null; |
| private TextBox login = new TextBox(); |
| private PasswordTextBox password = new PasswordTextBox(); |
| private Grid inner = new Grid(4,2); |
| public FormulaireDeConnexionVue(final ObservationMediateur carnetEnLigneMediateur) { |
| setText("Connexion"); |
| this.observationMediateur=carnetEnLigneMediateur; |
| VerticalPanel outer = new VerticalPanel(); |
| /* |
| * E-Mail : Zone_saisie_email |
| * Mot-de-passe : Zone_saisie_mot_de_passe |
| * Message d'information |
| * Bouton_Ok Bouton_Annuler |
| */ |
| // Validation bouton |
| HTML okButton=new HTML("Ok"); |
| okButton.setStyleName("html_button"); |
| okButton.addClickListener( |
| new ClickListener() { |
| public void onClick(Widget sender) { |
| connecteUtilisateur(); |
| } |
| } |
| ); |
| // Annulation |
| HTML cancelButton=new HTML("Annuler"); |
| cancelButton.setStyleName("html_button"); |
| cancelButton.addClickListener( |
| new ClickListener() { |
| public void onClick(Widget sender) { |
| hide(); |
| } |
| } |
| ); |
| //Validation utilisateur sans utilisation des boutons : |
| login.addKeyboardListener( new KeyboardListener() { |
| public void onKeyDown(Widget arg0, char arg1, int arg2) { |
| if(arg1 == KEY_ENTER) |
| { |
| connecteUtilisateur(); |
| } |
| } |
| public void onKeyUp(Widget arg0, char arg1, int arg2) { } |
| public void onKeyPress(Widget arg0, char arg1, int arg2) { } |
| } |
| ); |
| // Validation utilisateur sans utilisation des boutons : |
| password.addKeyboardListener( new KeyboardListener() { |
| public void onKeyDown(Widget arg0, char arg1, int arg2) { |
| if(arg1 == KEY_ENTER) |
| { |
| connecteUtilisateur(); |
| } |
| } |
| public void onKeyUp(Widget arg0, char arg1, int arg2) { } |
| public void onKeyPress(Widget arg0, char arg1, int arg2) { } |
| } |
| ); |
| inner.setHTML(0,0,"E-mail:"); |
| inner.setWidget(0,1,login); |
| inner.setHTML(1,0,"Mot de passe: "); |
| inner.setWidget(1,1,password); |
| inner.setWidget(3,0,okButton); |
| inner.setWidget(3,1,cancelButton); |
| inner.setCellPadding(10); |
| outer.add(inner); |
| setWidget(outer); |
| } |
| /** |
| * Appel du service d'identification et positionnement de l'etat de connection en fonction du resultat. |
| * |
| * @param login : identifiant saisi |
| * @param password : mot de passe saisi |
| * |
| */ |
| private void connecteUtilisateur() { |
| final String login=this.login.getText(); |
| String password=this.password.getText(); |
| observationMediateur.connecterUtilisateur(login,password); |
| } |
| public boolean onKeyDownPreview(char key, int modifiers) { |
| // Use the popup's key preview hooks to close the dialog when either |
| // escape is pressed. |
| switch (key) { |
| case KeyboardListener.KEY_ESCAPE: |
| hide(); |
| break; |
| } |
| return true; |
| } |
| public void afficherMessageAlerte() { |
| inner.setHTML(2,0,"Identification incorrecte !"); |
| } |
| } |
| /* +--Fin du code ---------------------------------------------------------------------------------------+ |
| * $Log: not supported by cvs2svn $ |
| * 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/observation/ListeObservationsVue.java |
|---|
| New file |
| 0,0 → 1,916 |
| /** |
| 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.ui.Button; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Composite; |
| import com.google.gwt.user.client.ui.DockPanel; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.HasVerticalAlignment; |
| import com.google.gwt.user.client.ui.HorizontalPanel; |
| import com.google.gwt.user.client.ui.Label; |
| import com.google.gwt.user.client.ui.Widget; |
| 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("<<", this); |
| public final Button gotoNext = new Button(">", this); |
| public final Button gotoPrev = new Button("<", this); |
| public final Button gotoEnd = new Button(">>", 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","Aransmis", 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(" "); |
| } |
| // 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(" "); |
| } |
| 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(" "); |
| } |
| 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(" "); |
| } |
| 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 tableur</a>"); |
| */ |
| // Mise a jour ligne de selection |
| String dep; |
| if (identifiantLocalite.compareTo("all")==0) { |
| dep="Tous départements"; |
| } |
| else { |
| if (identifiantLocalite.compareTo("000null")==0) { |
| dep="Départements non renseigné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é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é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ées"; |
| } |
| else { |
| if (annee.compareTo("0")==0) { |
| yea=", periode non renseigné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: not supported by cvs2svn $ |
| * 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/Util.java |
|---|
| New file |
| 0,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/CarnetEnLigne.java |
|---|
| New file |
| 0,0 → 1,54 |
| /** |
| Auteurs : |
| - David Delon david.delon@clapas.net 2007 |
| Licence Cecill/GPL |
| */ |
| /* |
| * CarnetEnLigne.java (Point d'entree de l'application carnet en ligne) |
| * |
| * |
| */ |
| package org.tela_botanica.client; |
| import com.google.gwt.core.client.EntryPoint; |
| /** |
| * Entry point classes define <code>onModuleLoad()</code>. |
| */ |
| public class CarnetEnLigne implements EntryPoint { |
| public void onModuleLoad() { |
| // new Mediator(); |
| new CarnetEnLigneMediateur(); |
| } |
| } |
| /* +--Fin du code ---------------------------------------------------------------------------------------+ |
| * $Log: not supported by cvs2svn $ |
| * Revision 1.1 2008-06-09 16:33:17 ddelon |
| * import branche observation |
| * |
| * Revision 1.1 2008-06-04 16:47:56 ddelon |
| * modele mvc+mediateur |
| * |
| * Revision 1.11 2008-01-02 21:26:04 ddelon |
| * mise en place mygwt |
| * |
| * Revision 1.10 2007-09-17 19:25:34 ddelon |
| * Documentation |
| * |
| * |
| */ |
| /trunk/src/org/tela_botanica/client/CarnetEnLigneMediateur.java |
|---|
| New file |
| 0,0 → 1,145 |
| package org.tela_botanica.client; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.iRetourUtilisateur; |
| import org.tela_botanica.client.modeles.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| public class CarnetEnLigneMediateur { |
| // Evenenements |
| final static public int ETAT_CONNEXION=1; |
| final static public int DECONNEXION=2; |
| final static public int CONNEXION = 3; |
| private final CarnetEnLigneModele carnetEnLigneModele; |
| private Utilisateur utilisateur=null; |
| // Fonctionnement servicecs |
| private boolean async=true; |
| public CarnetEnLigneMediateur() { |
| carnetEnLigneModele=new CarnetEnLigneModele(); |
| //addListener(ETAT_CONNEXION,this); |
| getEtatUtilisateur(); // Alimente Objet Utilisateur |
| } |
| /** |
| * Fin construction (est appelle sur reception evenement Applicatif ETAT_CONNEXION) |
| * |
| */ |
| private void _CarnetEnLigneMediateur() { |
| ImageMediateur.Instance() ; |
| new ObservationMediateur(this); |
| } |
| private void getEtatUtilisateur() { // Pourrait devenir publique ... |
| // TODO : utiliser une factory ici : Avec Modele synchrone ou non, ou au niveau methode comme dans cette exemple |
| // Pas possible de traiter dans Modele car retour asynchrone devant etre traité ici. |
| // if asynchrone |
| if (async) { |
| carnetEnLigneModele.getUtilisateurAsynchroneDAO( |
| new iRetourUtilisateur() { |
| public void onRetour(Utilisateur uti) { |
| utilisateur=uti; |
| // fireEvent(ETAT_CONNEXION); |
| } |
| } |
| ); |
| } |
| // else if synchrone |
| else { |
| utilisateur= carnetEnLigneModele.getUtilisateurSynchroneDAO(); |
| _CarnetEnLigneMediateur(); |
| } |
| } |
| // Evenenements Applicatifs |
| /* |
| public void handleEvent(BaseEvent be) { |
| if (be.type==CarnetEnLigneMediateur.ETAT_CONNEXION) { |
| _CarnetEnLigneMediateur(); // Fin initialisation |
| } |
| } |
| */ |
| // 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( |
| new iRetourUtilisateur() { |
| public void onRetour(Utilisateur uti) { |
| utilisateur=uti; |
| //fireEvent(DECONNEXION); |
| } |
| }, utilisateur.getIdentifiant() |
| ); |
| } |
| public void connecterUtilisateur(String login, String password) { |
| carnetEnLigneModele.connecterUtilisateur( |
| new iRetourUtilisateur() { |
| public void onRetour(Utilisateur uti) { |
| utilisateur=uti; |
| //fireEvent(CONNEXION); |
| } |
| }, login, password |
| ); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/image/ImageMediateur.java |
|---|
| New file |
| 0,0 → 1,1281 |
| package org.tela_botanica.client.image; |
| 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.PanneauFiltresVues; |
| import org.tela_botanica.client.vues.PanneauMetadonneesVue; |
| import org.tela_botanica.client.vues.ZoomImageVue; |
| 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.widgets.DataView; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.TabPanel; |
| import com.gwtext.client.widgets.event.TabPanelListenerAdapter; |
| 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 ObservationMediateur oMediateur = 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 final Panel panneauPrincipalImage = new Panel("Images"); |
| /** |
| * 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() |
| { |
| // 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); |
| afficherMenuId() ; |
| // 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 |
| panneauPrincipalImage.setLayout(new BorderLayout()); |
| panneauPrincipalImage.setId("x-main-panel-image") ; |
| // on crée le panneau des filtres |
| filtres = new PanneauFiltresVues(this) ; |
| // on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur |
| panneauMenuEtOngletsImage = new Panel() ; |
| panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ; |
| // 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.setAnimCollapse(true); |
| detailsEtMotsCles.setTitleCollapse(true); |
| detailsEtMotsCles.setCollapsible(true); |
| filtreMotsCles = new ArbreMotsClesFiltreVue(this) ; |
| filtreCommentaires = new BarreRechercheFiltreVue(this) ; |
| // 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) ; |
| // 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.setWidth("15%") ; |
| detailsEtMotsCles.setWidth("15%"); |
| ajouterListeners() ; |
| } |
| /** |
| * constructeur avec paramètres privé (on accède a la classe par la méthode getInstance) |
| * @param om le médiateur des observations à associer à la partie image |
| */ |
| private ImageMediateur(ObservationMediateur om) |
| { |
| oMediateur = om ; |
| // 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); |
| afficherMenuId() ; |
| // 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 |
| panneauPrincipalImage.setLayout(new BorderLayout()); |
| // on crée le panneau des filtres |
| filtres = new PanneauFiltresVues(this) ; |
| filtres.setWidth(200) ; |
| // on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur |
| panneauMenuEtOngletsImage = new Panel() ; |
| panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ; |
| // 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(zoomImage); |
| ongletsImage.add(panneauListeImage); |
| // 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); |
| filtreMotsCles = new ArbreMotsClesFiltreVue(this) ; |
| filtreCommentaires = new BarreRechercheFiltreVue(this) ; |
| // 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) ; |
| // 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 |
| //panneauMenuEtOngletsImage.add(filtres,regionOuest) ; |
| //filtres.setCollapsed(false) ; |
| } |
| /** |
| * 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) |
| { |
| estInstancie = true ; |
| return new ImageMediateur() ; |
| } |
| else |
| { |
| return null ; |
| } |
| } |
| /** |
| * Retourne une instance de manière unique en lui associant un médiateur pour les observations |
| * @param le médiateur des observations à associer |
| * @return l'instance unique du médiateur |
| */ |
| public static ImageMediateur Instance(ObservationMediateur om) |
| { |
| if(!estInstancie) |
| { |
| estInstancie = true ; |
| return new ImageMediateur(om) ; |
| } |
| else |
| { |
| return null ; |
| } |
| } |
| /** |
| * 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().obtenirPhotoGalerie(r) ; |
| } |
| /** |
| * demande au modèle les métadonnées associées a une image |
| * @param r la vue demandeuse de mise a jour |
| * @param id l'identifiant de l'image |
| */ |
| public void obtenirMetadonnees(Rafraichissable r, String id) |
| { |
| getIModele().obtenirMetadonnees(r, id) ; |
| } |
| /** |
| * demande au modèle les ids des mots clés associés a une image |
| * @param r la vue demandeuse de mise a jour |
| * @param id l'identifiant de l'image |
| */ |
| public void obtenirMotsClesId(Rafraichissable r, String id) |
| { |
| getIModele().obtenirMotsClesId(r, id) ; |
| } |
| /** |
| * 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[] imgXY = getIModele().obtenirTailleImage(rd.getAsString("num_image")) ; |
| String[] infosImage = {imgUrl , imgXY[0] , imgXY[1] } ; |
| getZoomImage().rafraichir(infosImage,false); |
| dernierIndexOnglet = 0 ; |
| if(DOM.eventGetType(e.getBrowserEvent()) == Event.ONDBLCLICK) |
| { |
| getOngletsImage().setActiveTab(2); |
| } |
| String imgNum = rd.getAsString("num_image"); |
| 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[] imgXY = getIModele().obtenirTailleImage(rd.getAsString("num_image")) ; |
| String[] infosImage = {imgUrl , imgXY[0] , imgXY[1] } ; |
| getZoomImage().rafraichir(infosImage,false); |
| dernierIndexOnglet = 1 ; |
| String imgNum = rd.getAsString("num_image"); |
| 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[] imgXY = getIModele().obtenirTailleImage(nRec.getAsString("num_image")) ; |
| String[] infosImage = {imgUrl , imgXY[0] , imgXY[1] } ; |
| getZoomImage().rafraichir(infosImage,false); |
| if(getGalerieImage().isRendered()) |
| { |
| getGalerieImage().getDView().select(storeIndex); |
| } |
| if(getListeImage().isRendered()) |
| { |
| getListeImage().getSelectionModel().selectRecords(nRec) ; |
| } |
| String imgNum = nRec.getAsString("num_image"); |
| 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() ; |
| 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 ; |
| } |
| public void ajouterListeners() |
| { |
| /*ongletsImage.addListener(new TabPanelListenerAdapter() { |
| public boolean doBeforeTabChange(TabPanel source, Panel newPanel, |
| Panel oldPanel) { |
| if(newPanel != null && newPanel.equals(getZoomImage())) |
| { |
| if(getGalerieImage() != null && getGalerieImage().getIdSelectionnees().length <= 0) |
| { |
| Window.alert("Aucune image selectionnée pour l'affichage !") ; |
| aucuneSelection() ; |
| return false ; |
| } |
| } |
| return true ; |
| } |
| public void onTabChange(TabPanel source, Panel tab) { |
| // TODO Auto-generated method stub |
| } |
| public void onActivate(Panel panel) { |
| // TODO Auto-generated method stub |
| } |
| }) ;*/ |
| } |
| } |
| /trunk/src/org/tela_botanica/client/image/ImageModele.java |
|---|
| New file |
| 0,0 → 1,742 |
| package org.tela_botanica.client.image; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| 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.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 ; |
| /** |
| * 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 obtenirPhotoGalerie(Rafraichissable r) |
| { |
| String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ; |
| int tailleFiltres = motsClesFiltres.length ; |
| String[][] criteres = new String[tailleFiltres+1][2] ; |
| String[][] criteres2 = new String[tailleFiltres+2][2] ; |
| String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ; |
| criteres[0] = utilisateur ; |
| String[] limite = {"ci_limite" ,""+taillePage } ; |
| String[] taillePage = {"ci_numero_page",""+pageEncours} ; |
| criteres2[0] = limite ; |
| criteres2[1] = taillePage ; |
| for (int i = 0 ; i < motsClesFiltres.length; i++) { |
| criteres[i+1] = motsClesFiltres[i] ; |
| criteres2[i+2] = motsClesFiltres[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) ; |
| // 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()][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<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() ; |
| 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[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage,defNoteImage}; |
| 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]) ; |
| } |
| } |
| /** |
| * 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 ; |
| obtenirPhotoGalerie(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) ; |
| obtenirPhotoGalerie(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 ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/BarreNotationVue.java |
|---|
| New file |
| 0,0 → 1,232 |
| 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 |
| */ |
| public String getNote() |
| { |
| return ""+noteEnCours ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/MenuImageVue.java |
|---|
| New file |
| 0,0 → 1,103 |
| 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 ; |
| /** |
| * 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") ; |
| addItem(uploaderImage); |
| addItem(supprimerImage) ; |
| // 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() ; |
| } |
| // 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/ZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,387 |
| 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.RegionPosition; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| 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 ; |
| /** |
| * 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 ; |
| // 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 |
| getImage().setUrl(infos[0]); |
| if(infos[1] != null && infos[2] != null) |
| { |
| int x = Integer.parseInt(infos[1]) ; |
| int y = Integer.parseInt(infos[2]) ; |
| setTailleImage(x,y) ; |
| 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") ; |
| } |
| /** |
| * 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; |
| } |
| /** |
| * 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 ; |
| } |
| /** |
| * renvoie la taille originale de l'image |
| * @return un tableau de deux entiers contenant la largeur puis la hauteur |
| */ |
| public int[] getTailleImage() |
| { |
| int[] taille = {imageHeight,imageWidth} ; |
| return taille ; |
| } |
| public Panel getImageConteneur() { |
| return imageConteneur ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/BarreRechercheFiltreVue.java |
|---|
| New file |
| 0,0 → 1,158 |
| 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() { |
| 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,0 → 1,99 |
| 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/PanneauMetadonneesVue.java |
|---|
| New file |
| 0,0 → 1,363 |
| 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 ; |
| /** |
| * 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) ; |
| 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) ; |
| 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 ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java |
|---|
| New file |
| 0,0 → 1,338 |
| 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/BarreOutilsVue.java |
|---|
| New file |
| 0,0 → 1,91 |
| 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/GalerieImageVue.java |
|---|
| New file |
| 0,0 → 1,309 |
| 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.google.gwt.user.client.Window; |
| 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.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; |
| /** |
| * 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(); |
| 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 ; |
| } |
| /** |
| * 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/pageToolBarVue.java |
|---|
| New file |
| 0,0 → 1,410 |
| 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/MenuIdVue.java |
|---|
| New file |
| 0,0 → 1,86 |
| 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/DateFiltreVue.java |
|---|
| New file |
| 0,0 → 1,148 |
| 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 aimge 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,0 → 1,437 |
| 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.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.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"); |
| // 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); |
| 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"); |
| } |
| } |
| }); |
| } |
| /** |
| * 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/PanneauFiltresVues.java |
|---|
| New file |
| 0,0 → 1,128 |
| 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 ; |
| /** |
| * 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) ; |
| 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() ) ; |
| } |
| /** |
| * 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() } ; |
| return filtres ; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,466 |
| 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/interfaces/VueListable.java |
|---|
| New file |
| 0,0 → 1,19 |
| 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,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 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,0 → 1,34 |
| 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,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/iRetourObservation.java |
|---|
| New file |
| 0,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,0 → 1,11 |
| package org.tela_botanica.client.interfaces; |
| /* |
| * Interface Mediateur |
| * |
| */ |
| public interface iMediateur { |
| } |
| /trunk/src/org/tela_botanica/client/interfaces/IRetourImage.java |
|---|
| New file |
| 0,0 → 1,9 |
| package org.tela_botanica.client.interfaces; |
| import org.tela_botanica.client.modeles.ListeImageCarnet; |
| public interface IRetourImage { |
| public void onRetour(ListeImageCarnet listeImage); |
| } |
| /trunk/src/org/tela_botanica/client/interfaces/IdVue.java |
|---|
| New file |
| 0,0 → 1,99 |
| 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/CarnetEnLigneModele.java |
|---|
| New file |
| 0,0 → 1,65 |
| 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.iRetourUtilisateur; |
| import org.tela_botanica.client.modeles.Utilisateur; |
| import org.tela_botanica.client.modeles.UtilisateurAsynchroneDAO; |
| import com.google.gwt.i18n.client.Dictionary; |
| public class CarnetEnLigneModele { |
| private final String baseURL; // Url d'appel aux services |
| /** |
| * Constructeur |
| */ |
| public CarnetEnLigneModele() { |
| baseURL=Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
| } |
| /** |
| * |
| * |
| */ |
| public void getUtilisateurAsynchroneDAO(final iRetourUtilisateur retour) { |
| new UtilisateurAsynchroneDAO().getUtilisateur(baseURL,retour ); |
| } |
| /** |
| * |
| * |
| */ |
| public Utilisateur getUtilisateurSynchroneDAO() { |
| return new Utilisateur("David Delon synchrone",true); |
| } |
| public void deconnecterUtilisateur(final iRetourUtilisateur retour, String user) { |
| new UtilisateurAsynchroneDAO().deconnecterUtilisateur(baseURL,retour,user ); |
| } |
| public void connecterUtilisateur(final iRetourUtilisateur retour, String login , String password) { |
| new UtilisateurAsynchroneDAO().connecteUtilisateur(baseURL,retour,login, password ); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/cel2.java |
|---|
| New file |
| 0,0 → 1,22 |
| package org.tela_botanica.client; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.google.gwt.core.client.EntryPoint; |
| 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() { |
| ImageMediateur im = ImageMediateur.Instance() ; |
| new Viewport(im.getPanneauPrincipalImage()); |
| } |
| } |
| /trunk/src/org/tela_botanica/client/g |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /trunk/src/org/tela_botanica/client/g |
|---|
| New file |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |