Subversion Repositories eFlore/Applications.cel

Compare Revisions

Regard whitespace Rev 4 → Rev 5

/trunk/src/org/tela_botanica/client/interfaces/VueListable.java
2,9 → 2,10
 
/**
* 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
* 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
*
*/
12,6 → 13,7
 
/**
* 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
1,11 → 1,13
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
* 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
*
*/
13,9 → 15,15
/**
* 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
*
* @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);
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement);
 
}
/trunk/src/org/tela_botanica/client/interfaces/Filtrable.java
1,9 → 1,10
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
* 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
*
*/
11,23 → 12,31
/**
* 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
*
* @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)
* 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
*
* @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
* 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/iMediateur.java
1,6 → 1,5
package org.tela_botanica.client.interfaces;
 
 
/*
* Interface Mediateur
*
/trunk/src/org/tela_botanica/client/interfaces/IdVue.java
18,8 → 18,7
private TextField champId = null ;
private Button ok = null ;
public IdVue(ImageMediateur im)
{
public IdVue(ImageMediateur im) {
super("Identification") ;
iMediateur = im ;
35,7 → 34,6
setModal(true) ;
this.setCloseAction(HIDE) ;
ajouterListeners() ;
}
44,7 → 42,6
// gestion du clic sur le bouton
ok.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
valider() ;
60,7 → 57,6
valider() ;
}
}) ;
this.addListener(new WindowListenerAdapter() {
67,16 → 63,13
 
public void onClose(Panel panel) {
}
});
 
}
public ImageMediateur getIMediateur()
{
public ImageMediateur getIMediateur() {
return iMediateur ;
}
92,8 → 85,6
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
}
 
 
}
/trunk/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java
16,8 → 16,9
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é
* Data Object Access communiquant avec le serveur jrest fournissant la liste
* des images répondant à des critères donné
*
* @author aurelien
*
*/
28,39 → 29,39
*/
ImageModele iModele = null ;
public ListeImageAsynchroneDAO(ImageModele im)
{
public ListeImageAsynchroneDAO(ImageModele im) {
iModele = im ;
}
/**
* Setteur pour le modèle
* @param im le modèle à associer
*
* @param im
* le modèle à associer
*/
public void setIModele(ImageModele im)
{
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
* 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)
{
public void ObtenirListeImages(final Rafraichissable r, String[][] criteres) {
String requete = "" ;
// on construit les paramètres du get
if(criteres != null)
{
if (criteres != null) {
for (int i = 0; i < criteres.length; i++) {
if(!criteres[i][1].equals(""))
{
if(i!= 0)
{
if (!criteres[i][1].equals("")) {
if (i != 0) {
requete += "&";
}
requete += criteres[i][0]+"="+criteres[i][1] ;
70,7 → 71,12
}
// on envoie le get asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET,iModele.getConfig().getServiceBaseUrl()+"/InventoryImageList/"+iModele.getIdentifiant()+"/"+requete) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryImageList/"
+ iModele.getIdentifiant()
+ "/"
+ requete);
try {
rb.sendRequest(null , new RequestCallback() {
79,11 → 85,13
}
 
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
final ListeImageCarnet photoData ;
 
final JSONValue responseValue = JSONParser.parse(response.getText());
final JSONValue responseValue = JSONParser.parse(response
.getText());
// si c'est un tableau
if (responseValue.isArray() != null) {
99,29 → 107,29
ImageCarnet im = new ImageCarnet(image) ;
// et on en extrait les données pour construire la liste d'image
// et on en extrait les données pour construire la
// liste d'image
photoData.put(im.getOrdre(),im) ;
}
}
else
{
} else {
// si c'est un objet alors il n'y a qu'une réponse
if(responseValue.isObject() != null)
{
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
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
{
} 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
// 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);
}
135,30 → 143,33
/**
* 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
*
* @param li
* la liste d'image à synchroniser avec la base
*/
public void SynchroniserBaseDeDonnees(ListeImageCarnet li)
{
public void SynchroniserBaseDeDonnees(ListeImageCarnet li) {
// on parcourt toute la liste d'image
for(Iterator<String> listIt = li.keySet().iterator() ; listIt.hasNext() ;)
{
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();)
{
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) ;
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()+"/") ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImage/" + iModele.getIdentifiant() + "/");
try {
rb.sendRequest(postData, new RequestCallback() {
170,14 → 181,12
public void onResponseReceived(Request request,
Response response) {
if(response.getText().equals("OK"))
{
if (response.getText().equals("OK")) {
return ;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
191,12 → 200,14
/**
* Supprime des image sur le serveur par rapport à leur identifant
* @param ids un tableau d'identifiants d'images à supprimer
*
* @param ids
* un tableau d'identifiants d'images à supprimer
*/
public void supprimerBaseDeDonnees(String[] ids)
{
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)
// on fait un delete dans le post (jrest ne gère pas delete comme une
// action à part entière)
postData += "&action=DELETE" ;
String uid = "" ;
208,7 → 219,9
}
// et on envoie ça au serveur
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().getServiceBaseUrl()+"/inventoryImageList/"+iModele.getIdentifiant()+"/"+uid) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImageList/" + iModele.getIdentifiant() + "/" + uid);
try {
rb.sendRequest(postData, new RequestCallback() {
 
217,10 → 230,11
}
 
public void onResponseReceived(Request request, Response response) {
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
// 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() ;
233,5 → 247,4
}
}
 
}
/trunk/src/org/tela_botanica/client/modeles/NombreImageAsynchroneDAO.java
12,7 → 12,9
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)
* DAO qui renvoie le nombre d'image associées à différents critères donnés
* (utile pour la pagination)
*
* @author aurelien
*
*/
23,39 → 25,39
*/
private ImageModele iModele = null ;
public NombreImageAsynchroneDAO(ImageModele im)
{
public NombreImageAsynchroneDAO(ImageModele im) {
iModele = im ;
}
/**
* Setteur pour le modèle
* @param im le modèlme à associer
*
* @param im
* le modèlme à associer
*/
public void setIModele(ImageModele im)
{
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
* 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)
{
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...)
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)
{
if (!criteres[i][1].equals("")) {
if (i != 0) {
requete += "&";
}
requete += criteres[i][0]+"="+criteres[i][1] ;
64,7 → 66,12
}
// on fait un get asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele.getConfig().getServiceBaseUrl()+"/InventoryImageCount/"+iModele.getIdentifiant()+"/"+requete) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryImageCount/"
+ iModele.getIdentifiant()
+ "/"
+ requete);
try {
rb.sendRequest(null, new RequestCallback() {
 
73,19 → 80,23
}
 
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
final JSONValue responseValue = JSONParser.parse(response.getText());
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
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 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
// on le met dans un tableau d'entiers qu'on transmet au
// demandeur de la mise à jour
r.rafraichir(nbImages, true) ;
}
/trunk/src/org/tela_botanica/client/modeles/Configuration.java
3,7 → 3,9
import com.google.gwt.i18n.client.Dictionary;
 
/**
* Classe chargeant certains paramètres de configuration à partir d'un fichier javascript (config.js)
* Classe chargeant certains paramètres de configuration à partir d'un fichier
* javascript (config.js)
*
* @author aurelien
*
*/
14,21 → 16,24
*/
private String serviceBaseUrl ;
private String imageBaseUrl;
 
/**
* Constructeur sans argument
*/
public Configuration()
{
// on utilise le dictionnaire d'internationalisation pour lire les variables du fichier javascript
serviceBaseUrl = Dictionary.getDictionary("configuration").get("serviceBaseUrl") ;
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()
{
public String getServiceBaseUrl() {
return serviceBaseUrl ;
}
 
/trunk/src/org/tela_botanica/client/modeles/MotsClesAsynchroneDAO.java
1,6 → 1,5
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;
15,6 → 14,7
 
/**
* DAO d'accès à l'arbre de mots clés
*
* @author aurelien
*
*/
25,28 → 25,31
*/
private ImageModele iModele = null ;
public MotsClesAsynchroneDAO(ImageModele im)
{
public MotsClesAsynchroneDAO(ImageModele im) {
iModele = im ;
}
/**
* Setteur pour le modèle
* @param im le modèle à associer
*
* @param im
* le modèle à associer
*/
public void setIModele(ImageModele im)
{
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
*
* @param r
* le rafraichissable qui demande les données
*/
public void obtenirListeMotsCles(final Rafraichissable r)
{
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()) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryKeyWordList/" + iModele.getIdentifiant());
try {
rb.sendRequest(null, new RequestCallback() {
56,9 → 59,11
}
 
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
final JSONValue responseValue = JSONParser.parse(response.getText());
final JSONValue responseValue = JSONParser.parse(response
.getText());
// si la requête est un succès on reçoit un tableau
if (responseValue.isArray() != null) {
78,16 → 83,18
/**
* Envoie requete au serveur jrest pour ajouter un mot clé
* @param motcle le mots clés à ajouter avec son parent et son identifiant
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
*/
public void ajouterBaseDeDonnees(String motcle)
{
if(!motcle.equals(""))
{
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/") ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryKeyWordList/");
try {
rb.sendRequest(postData, new RequestCallback() {
 
99,11 → 106,12
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. ") ;
// 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. ");
}
}
118,16 → 126,21
/**
* Envoie requete au serveur jrest pour supprimer un mot clé
* @param motcle le mots clés à supprimer
*
* @param motcle
* le mots clés à supprimer
*/
public void supprimerBaseDeDonnees(String motcle)
{
if(!motcle.equals(""))
{
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) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryKeyWordList/"
+ iModele.getIdentifiant()
+ "/"
+ motcle);
try {
rb.sendRequest(postData, new RequestCallback() {
139,10 → 152,10
 
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. ") ;
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. ");
}
}
});
156,17 → 169,20
 
/**
* Envoie requete au serveur jrest pour modifier un mot clé
* @param motcle le mots clés à modifier avec son parent et son identifiant
*
* @param motcle
* le mots clés à modifier avec son parent et son identifiant
*/
public void modifierBaseDeDonnees(String motcle) {
if(!motcle.equals(""))
{
if (!motcle.equals("")) {
 
String postData = "" ;
postData += "&action=modification"+motcle ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+iModele.getIdentifiant()) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryKeyWordList/" + iModele.getIdentifiant());
try {
rb.sendRequest(postData, new RequestCallback() {
175,7 → 191,8
}
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
// TODO Auto-generated method stub
}
190,17 → 207,21
/**
* 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
*
* @param motcle
* le mots clés à ajouter avec son ancien parent, son nouveau et
* son identifiant
*/
public void deplacerBaseDeDonnees(String motcle) {
if(!motcle.equals(""))
{
if (!motcle.equals("")) {
 
String postData = "" ;
postData += "&action=deplacement"+motcle ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,iModele.getConfig().getServiceBaseUrl()+"/InventoryKeyWordList/"+iModele.getIdentifiant()) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/InventoryKeyWordList/" + iModele.getIdentifiant());
try {
rb.sendRequest(postData, new RequestCallback() {
209,7 → 230,8
}
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
// TODO Auto-generated method stub
}
/trunk/src/org/tela_botanica/client/modeles/LienImageAsynchroneDAO.java
New file
0,0 → 1,99
package org.tela_botanica.client.modeles;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.user.client.Window;
 
public class LienImageAsynchroneDAO {
 
private ImageModele iModele = null ;
public LienImageAsynchroneDAO(ImageModele im) {
iModele = im;
}
 
/**
* Setteur pour le modèle
*
* @param im
* le modèle à associer
*/
public void setIModele(ImageModele im) {
iModele = im;
}
public void obtenirLiaisonsImagesObservations(Rafraichissable r,String id)
{
String paramGet = "&coi_ce_image="+id ;
 
// et on envoie ça au serveur
RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImageLink/" + iModele.getIdentifiant() + "/" + paramGet);
try {
rb.sendRequest(null, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
public void onResponseReceived(Request request,
Response response) {
 
Window.alert(response.toString()) ;
 
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void lierImageBaseDeDonnees(String idsImages, String idsObs) {
String postData = "";
postData += "&coi_ce_image="+idsImages ;
postData += "&coi_ce_observation="+idsObs ;
postData += "&identifiant="+iModele.getIdentifiant() ;
 
Window.alert("data postée : "+postData) ;
// et on envoie ça au serveur
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImageLink/");
try {
rb.sendRequest(postData, new RequestCallback() {
 
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
public void onResponseReceived(Request request,
Response response) {
 
// quand la requête est éxecutée on le signale au modèle
// poru qu'il mette à jour les données
// et en notifie le médiateur
// iModele.requeteTerminee();
 
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/trunk/src/org/tela_botanica/client/modeles/UtilisateurAsynchroneDAO.java
17,8 → 17,6
 
public class UtilisateurAsynchroneDAO {
 
/**
* Constructeur
*/
26,12 → 24,13
public UtilisateurAsynchroneDAO() {
}
/**
* Methode de classe d'appel du service gestion identification
* @param baseURL : URL du service
* @param retour : methode appelle en retour d'appel
*
* @param baseURL :
* URL du service
* @param retour :
* methode appelle en retour d'appel
*/
public void getUtilisateur(String baseURL, final iRetourUtilisateur retour) {
58,10 → 57,9
 
}
 
public void deconnecterUtilisateur(String baseURL,
final iRetourUtilisateur retour, String user) {
 
 
public void deconnecterUtilisateur(String baseURL, final iRetourUtilisateur retour, String user) {
 
HTTPRequest.asyncGet(baseURL + "/User/" + user ,
new ResponseTextHandler() {
 
71,24 → 69,25
JSONArray jsonArray;
if ((jsonArray = jsonValue.isArray()) != null) {
String identifiant = ((JSONString) jsonArray.get(0))
.stringValue(); // Identifiant utilisateur ou
.stringValue(); // Identifiant utilisateur
// ou
// identifiant de session si non
// identifie
boolean identifie = ((JSONBoolean) jsonArray.get(1))
.booleanValue(); // Drapeau leve si utilisateur
.booleanValue(); // Drapeau leve si
// utilisateur
// deja identifie
 
retour.onRetour(new Utilisateur(identifiant, identifie));
retour.onRetour(new Utilisateur(identifiant,
identifie));
}
}
});
}
 
public void connecteUtilisateur(String baseURL,
final iRetourUtilisateur retour, String login, String password) {
 
 
public void connecteUtilisateur(String baseURL,final iRetourUtilisateur retour, String login, String password) {
 
HTTPRequest.asyncGet(baseURL + "/User/" + login + "/" + password ,
new ResponseTextHandler() {
 
99,15 → 98,17
if ((jsonArray = jsonValue.isArray()) != null) {
String identifiant = ((JSONString) jsonArray.get(0))
.stringValue(); // Identifiant utilisateur ou
.stringValue(); // Identifiant utilisateur
// ou
// identifiant de session si non
// identifie
boolean identifie = ((JSONBoolean) jsonArray.get(1))
.booleanValue(); // Drapeau leve si utilisateur
.booleanValue(); // Drapeau leve si
// utilisateur
// deja identifie
 
retour.onRetour(new Utilisateur(identifiant, identifie));
retour.onRetour(new Utilisateur(identifiant,
identifie));
}
}
});
/trunk/src/org/tela_botanica/client/modeles/ObservationAsynchroneDAO.java
19,8 → 19,6
 
public class ObservationAsynchroneDAO {
 
/**
* Constructeur
*/
27,22 → 25,27
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) {
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() {
 
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()));
retour
.onRetour(new Observation((int) jsonNumber
.getValue()));
}
}
});
49,15 → 52,18
 
}
 
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,
 
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) {
78,21 → 84,46
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();
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);
listeObservation[i] = new Observation(transmis,
nomSaisi, nomRetenu,
numeroNomenclatural, numeroTaxonomique,
famille, localite, lieudit, station,
milieu, commentaire, date, numeroOrdre);
}
}
retour.onRetour(new Observation(listeObservation));
106,7 → 137,4
}
 
 
 
 
}
/trunk/src/org/tela_botanica/client/modeles/Utilisateur.java
2,7 → 2,6
 
public class Utilisateur {
 
private String identifiant=null;
private boolean identifie=false;
 
11,9 → 10,10
this.identifie=identifie;
}
 
/**
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de
* session
*
* @return String identifiant
*/
23,6 → 23,7
 
/**
* Retourne vrai si utilisateur identifie
*
* @return boolean
*/
/trunk/src/org/tela_botanica/client/modeles/Observation.java
1,9 → 1,7
package org.tela_botanica.client.modeles;
 
 
public class Observation {
 
 
private int nombreObservations=0;
private Observation [] listeObservation=null;
 
21,14 → 19,12
private String date=null;
private String numeroOrdre=null;
 
 
public Observation() {
}
 
/**
* Constructeur nombre total d'observations
*
* @param i
*/
36,13 → 32,10
nombreObservations=i;
}
 
public int getNombreObservations() {
return nombreObservations;
}
 
 
/**
* @param transmis
* @param nomSaisi
58,7 → 51,10
* @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) {
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;
76,7 → 72,6
}
 
 
public Observation(Observation[] listeObservation) {
this.listeObservation=listeObservation;
}
85,11 → 80,8
return listeObservation;
}
 
 
public String getNomSaisi() {
return nomSaisi;
}
 
}
/trunk/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java
9,10 → 9,9
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
* DAO un peu particulier car il crée une fenetre d'upload différente suivant
* que le plugin Java est détecté ou non
*
*
*/
23,26 → 22,26
*/
private static ImageModele iModele ;
public ImageUploaderAsynchroneDAO(ImageModele im)
{
public ImageUploaderAsynchroneDAO(ImageModele im) {
iModele = im ;
}
/**
* Setteur pour le modele
* @param im le modèle à associer au DAO
*
* @param im
* le modèle à associer au DAO
*/
public void setIModele(ImageModele im)
{
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)
* 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()
{
private static void appelerUploadSimple() {
UploadDialog up = new UploadDialog("Upload simple de fichiers") ;
up.setUrl(iModele.getConfig().getServiceBaseUrl()+"/InventoryImage");
64,7 → 63,6
}
 
});
up.show();
72,12 → 70,12
}
/**
* 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)
* 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()
{
private static void appelerUploadMultiple() {
final Window nPan = new Window("Upload multiple");
nPan.setWidth(640) ;
85,7 → 83,9
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 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\">";
97,23 → 97,15
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
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>" ;
final String htmlForm = "<form method=\"post\" name=\"postid\">"
+ "<input type=\"hidden\" name=\"identifiant\" value=\""
+ iModele.getIdentifiant() + "\">" + "</form>";
 
nPan.setHtml(warning+appelApplet+htmlForm);
121,8 → 113,6
nPan.addListener(new WindowListenerAdapter() {
 
 
public void onClose(Panel panel) {
iModele.requeteTerminee() ;
129,7 → 119,6
}
});
nPan.show();
136,8 → 125,9
}
/**
* 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)
* 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() /*-{
/trunk/src/org/tela_botanica/client/modeles/ImageCarnet.java
5,17 → 5,16
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
* 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> {
 
/**
*
*/
23,10 → 22,10
 
/**
* Constructeur avec un objet JSON
*
* @param image
*/
public ImageCarnet(JSONObject image)
{
public ImageCarnet(JSONObject image) {
// l'objet JSON est une table de hachage
Set<String> im = image.keySet() ;
35,13 → 34,10
// si elle est associée à une valeur, on l'ajoute
String key = iterator.next();
if(image.get(key).isString() != null)
{
if (image.get(key).isString() != null) {
String valeur = image.get(key).isString().stringValue() ;
this.put(key, valeur) ;
}
else
{
} else {
// sinon on ajoute la clé avec une valeur vide
String valeur = " " ;
this.put(key, valeur) ;
55,16 → 51,14
* Surcharge de toString qui affiche toutes les propriétés de l'image
*/
public String toString()
{
public String toString() {
String valeur = " ";
for (Iterator<String> iterator = this.keySet().iterator(); iterator.hasNext();) {
for (Iterator<String> iterator = this.keySet().iterator(); iterator
.hasNext();) {
String key = iterator.next();
if(this.get(key) != null)
{
if (this.get(key) != null) {
valeur += "cle : "+key+" valeur :"+this.get(key)+"\n" ;
}
74,31 → 68,25
}
/**
* 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
* 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)))
{
public String renvoyerValeurCorrecte(String cle) {
if (this.containsKey((cle))) {
String valeur = this.get(cle) ;
if(valeur.equals("null") || valeur == null)
{
if (valeur.equals("null") || valeur == null) {
return " " ;
}
else
{
} else {
char nullChar = '\u0000' ;
String sNull = ""+nullChar ;
valeur = valeur.replaceAll(sNull, "") ;
return valeur ;
}
}
else
{
} else {
return " " ;
}
}
105,6 → 93,7
 
/**
* Acesseur pour l'id de l'image
*
* @return l'id de l'image
*/
public String getId() {
114,6 → 103,7
/**
* Acesseur pour le numero d'ordre de l'image
*
* @return l'ordre de l'image
*/
public String getOrdre() {
123,25 → 113,25
/**
* Base de l'url serveur pour les images
*
* @return url racine pour les images
*/
public String getBaseUrl()
{
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
*
* @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous
* dossier
*/
public String[] getBaseFileName()
{
public String[] getBaseFileName() {
String id = getId() ;
int maxZeros = 9 - id.length() ;
for(int i = 0 ; i < maxZeros ; i++)
{
for (int i = 0; i < maxZeros; i++) {
id = "0"+id ;
}
158,6 → 148,7
 
/**
* Renvoie le chemin et nom du fichier grand format
*
* @return le chemin du fichier grand format
*/
public String getLUrl() {
164,11 → 155,13
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/L/"+infosFichier[0]+"_L.jpg" ;
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() {
175,11 → 168,13
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/S/"+infosFichier[0]+"_S.jpg" ;
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() {
186,21 → 181,22
String[] infosFichier = getBaseFileName() ;
return getBaseUrl()+infosFichier[1]+"/"+infosFichier[2]+"/M/"+infosFichier[0]+"_M.jpg" ;
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") } ;
public String[] getTailleImage() {
String[] XY = { renvoyerValeurCorrecte("ci_meta_height"),
renvoyerValeurCorrecte("ci_meta_width") };
return XY ;
}
public String[] getNote()
{
public String[] getNote() {
String[] note = {renvoyerValeurCorrecte("ci_note_image") } ;
return note ;
}
207,6 → 203,7
/**
* Renvoie la date exif associée à l'image
*
* @return la date associée à l'image
*/
public String getDate() {
216,6 → 213,7
 
/**
* Renvoie la ville associée à l'image
*
* @return la ville iptc
*/
public Object getIptcCity() {
225,6 → 223,7
 
/**
* Renvoie le fabricant de l'appareil
*
* @return le fabricant
*/
public String getMake() {
234,6 → 233,7
 
/**
* Renvoie le modele de l'appareil
*
* @return le modele
*/
public String getModel() {
243,6 → 243,7
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
*
* @return les métadonnées iptc
*/
public String[][] getMetadonnesIptc() {
250,8 → 251,7
String[][] metaIptc = new String[14][2] ;
int elem = 0 ;
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
{
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
String key = it.next();
258,13 → 258,10
// on filtre le "ci"
String type[] = key.split("_",3) ;
// si c'est une metadonnee exif ou iptc
if(type[1].equals("meta"))
{
if (type[1].equals("meta")) {
String[] genre = type[2].split("_",2) ;
if(genre[0].equals("iptc"))
{
if (genre[0].equals("iptc")) {
String nom = genre[1] ;
metaIptc[elem][0] = nom ;
metaIptc[elem][1] = renvoyerValeurCorrecte(key) ;
280,6 → 277,7
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Exif
*
* @return les métadonnées Exif
*/
public String[][] getMetadonnesExif() {
287,8 → 285,7
String[][] metaExif = new String[31][2] ;
int elem = 0 ;
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();)
{
for (Iterator<String> it = this.keySet().iterator(); it.hasNext();) {
String key = it.next();
295,13 → 292,10
// on filtre le "ci"
String type[] = key.split("_",3) ;
// si c'est une metadonnee exif ou iptc
if(type[1].equals("meta"))
{
if (type[1].equals("meta")) {
String[] genre = type[2].split("_",2) ;
if(genre[0].equals("exif"))
{
if (genre[0].equals("exif")) {
String nom = genre[1] ;
metaExif[elem][0] = nom ;
metaExif[elem][1] = renvoyerValeurCorrecte(key) ;
318,6 → 312,7
/**
* Renvoie un tableau nom / valeur contenant les infos générales
*
* @return les infos générales
*/
public String[][] getInfoGenerales() {
335,6 → 330,7
/**
* Renvoie une string contenant les mots clés séparés par des ','
*
* @return les mots clés
*/
public String getMotsCles() {
344,11 → 340,14
/**
* Met à jour le commenentaire et la date
* @param commentaires le nouveau commentaire
* @param date la nouvelle date
*
* @param commentaires
* le nouveau commentaire
* @param date
* la nouvelle date
*/
public void miseAJourInfoGenerales(String commentaires, String date, String note)
{
public void miseAJourInfoGenerales(String commentaires, String date,
String note) {
put("ci_meta_comment",commentaires) ;
put("ci_note_image",note) ;
put("ci_meta_date",date) ;
356,7 → 355,9
/**
* Met à jour les mots clés
* @param motsClesEnCours la liste de mots clés séparés par des ','
*
* @param motsClesEnCours
* la liste de mots clés séparés par des ','
*/
public void mettreAjourMotsCles(String motsClesEnCours) {
/trunk/src/org/tela_botanica/client/modeles/ImageAsynchroneDAO.java
10,8 → 10,9
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
* 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
*
*/
19,27 → 20,25
 
ImageModele iModele = null ;
public ImageAsynchroneDAO(ImageModele im)
{
public ImageAsynchroneDAO(ImageModele im) {
iModele = im ;
}
public void setIModele(ImageModele 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
*
* @param ic
* l'image à mettre à jour
*/
public void SynchroniserBaseDeDonnees(final ImageCarnet ic)
{
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();)
{
for (Iterator<String> imgIt = ic.keySet().iterator(); imgIt.hasNext();) {
String key = imgIt.next() ;
String valeur = ic.renvoyerValeurCorrecte(key) ;
48,7 → 47,9
}
 
// et on envoie une requête asynchrone
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele.getConfig().getServiceBaseUrl()+"/inventoryImage/"+iModele.getIdentifiant()+"/") ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImage/" + iModele.getIdentifiant() + "/");
try {
rb.sendRequest(postData, new RequestCallback() {
58,17 → 59,16
}
 
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
if(response.getText().equals("OK"))
{
if (response.getText().equals("OK")) {
return ;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
80,10 → 80,11
/**
* Met à jour la base de données avec les mots clés associés à l'image
* @param ic l'image à mettre à jour
*
* @param ic
* l'image à mettre à jour
*/
public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic)
{
public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) {
String postData = "" ;
// on récupère les mots clés de l'image et on fabrique le post
92,7 → 93,9
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()+"/") ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImage/" + iModele.getIdentifiant() + "/");
try {
rb.sendRequest(postData, new RequestCallback() {
102,17 → 105,16
}
 
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
if(response.getText().equals("OK"))
{
if (response.getText().equals("OK")) {
return ;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
124,16 → 126,23
/**
* Supprime une image de la base de données
* @param ic l'image à supprimer
*
* @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)
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()) ;
RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, iModele
.getConfig().getServiceBaseUrl()
+ "/inventoryImage/"
+ iModele.getIdentifiant()
+ "/"
+ ic.getId());
try {
rb.sendRequest(postData, new RequestCallback() {
143,17 → 152,16
}
public void onResponseReceived(Request request, Response response) {
public void onResponseReceived(Request request,
Response response) {
if(response.getText().equals("OK"))
{
if (response.getText().equals("OK")) {
return ;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
else
{
com.google.gwt.user.client.Window.alert("Problème lors de la mise à jour des données") ;
}
}
}) ;
/trunk/src/org/tela_botanica/client/modeles/ListeImageCarnet.java
4,11 → 4,11
 
/**
* 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>
* 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
*
*/
22,31 → 22,30
/**
* Constructeur sans paramètres
*/
public ListeImageCarnet()
{
public ListeImageCarnet() {
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*
* @param taille
* la taille de la table de hachage
*/
public ListeImageCarnet(int taille)
{
public ListeImageCarnet(int taille) {
super(taille);
}
/**
* Constructeur avec paramètre
* @param ic un tableau d'ImageCarnet
*
* @param ic
* un tableau d'ImageCarnet
*/
public ListeImageCarnet(ImageCarnet[] ic)
{
public ListeImageCarnet(ImageCarnet[] ic) {
super() ;
for (int i = 0; i < ic.length; i++)
{
if(ic[i] != null && ic[i] instanceof ImageCarnet)
{
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/image/ImageMediateur.java
1,5 → 1,6
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;
10,6 → 11,7
import org.tela_botanica.client.vues.GalerieImageVue;
import org.tela_botanica.client.vues.ListeImageVue;
import org.tela_botanica.client.vues.MenuImageVue;
import org.tela_botanica.client.vues.MiniListeObservationVue;
import org.tela_botanica.client.vues.PanneauFiltresVues;
import org.tela_botanica.client.vues.PanneauMetadonneesVue;
import org.tela_botanica.client.vues.ZoomImageVue;
25,10 → 27,12
import com.gwtext.client.data.Record;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.widgets.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.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
import com.gwtext.client.widgets.layout.FitLayout;
40,8 → 44,9
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
* Mediateur gérant les interactions entre vues et les echanges de données
* C'est un singleton.
* Mediateur gérant les interactions entre vues et les echanges de données C'est
* un singleton.
*
* @author aurelien
*
*/
63,8 → 68,7
private ImageModele iModele = null ;
/**
* L'identifiant utilisateur.
* Par défaut, il vaut 0
* L'identifiant utilisateur. Par défaut, il vaut 0
*/
private String identifiant = "0" ;
 
146,8 → 150,7
/**
* constructeur privé (on accède a la classe par la méthode getInstance)
*/
private ImageMediateur()
{
private ImageMediateur() {
// quelques variables de position pour les borderlayouts
final BorderLayoutData regionNord = new BorderLayoutData(
RegionPosition.NORTH) ;
165,7 → 168,6
afficherMenuId() ;
 
// on crée un modèle
iModele = ImageModele.Instance(this);
// et on demande l'arbre des mots clés
178,7 → 180,8
// 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
// on crée le panneau qui contient les differentes onglets ainsi que le
// menu supérieur
panneauMenuEtOngletsImage = new Panel() ;
panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ;
219,18 → 222,19
// 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
// 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
// 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) ;
237,16 → 241,16
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
* 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)
{
private ImageMediateur(ObservationMediateur om) {
oMediateur = om ;
// quelques variables de position pour les borderlayouts
266,7 → 270,6
afficherMenuId() ;
 
// on crée un modèle
iModele = ImageModele.Instance(this);
// et on demande l'arbre des mots clés
279,7 → 282,8
filtres = new PanneauFiltresVues(this) ;
filtres.setWidth(200) ;
// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
// on crée le panneau qui contient les differentes onglets ainsi que le
// menu supérieur
panneauMenuEtOngletsImage = new Panel() ;
panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ;
300,8 → 304,8
// on ajoute les panneaux au panneau à onglets
ongletsImage.add(galerieImage);
ongletsImage.add(panneauListeImage);
ongletsImage.add(zoomImage);
ongletsImage.add(panneauListeImage);
// on crée les menu et la barre de vue
menuImageVue = new MenuImageVue(this) ;
321,12 → 325,14
// 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
// 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
// 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);
340,7 → 346,9
/**
* Change la valeur du booleen de selection
* @param selection la nouvelle valeur du booléen
*
* @param selection
* la nouvelle valeur du booléen
*/
public void setSelection(boolean selection) {
this.selection = selection;
348,6 → 356,7
 
/**
* renvoie la valeur du booleen de selection
*
* @return la valeur du booleen de selection
*/
public boolean isSelection() {
356,17 → 365,14
 
/**
* Retourne une instance de manière unique
*
* @return l'instance unique du médiateur
*/
public static ImageMediateur Instance()
{
if(!estInstancie)
{
public static ImageMediateur Instance() {
if (!estInstancie) {
estInstancie = true ;
return new ImageMediateur() ;
}
else
{
} else {
return null ;
}
373,19 → 379,18
}
/**
* Retourne une instance de manière unique en lui associant un médiateur pour les observations
* @param le médiateur des observations à associer
* 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)
{
public static ImageMediateur Instance(ObservationMediateur om) {
if (!estInstancie) {
estInstancie = true ;
return new ImageMediateur(om) ;
}
else
{
} else {
return null ;
}
393,28 → 398,29
/**
* Renvoie l'identifiant de l'utilisateur en cours
*
* @return l'identifiant de l'utilisateur
*/
public String getIdentifiant()
{
public String getIdentifiant() {
return identifiant ;
}
/**.
* Setteur pour l'identifiant de l'utilisateur en cours
* @param id le nouvel identifiant utilisateur
/**
* . Setteur pour l'identifiant de l'utilisateur en cours
*
* @param id
* le nouvel identifiant utilisateur
*/
public void setIdentifiant(String id)
{
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
* 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()
{
public void changerUtilisateur() {
getIModele().initialiserArbreMotsCles() ;
obtenirPhotoGalerie(getGalerieImage()) ;
}
421,6 → 427,7
 
/**
* Accesseur pour le modèle associé au médiateur
*
* @return le modèle associé
*/
public ImageModele getIModele() {
429,6 → 436,7
 
/**
* Accesseur pour le panneau principal
*
* @return le panneau principal
*/
public Panel getPanneauPrincipalImage() {
437,6 → 445,7
 
/**
* Accesseur pour le panneau à onglets
*
* @return le panneau à onglets
*/
public TabPanel getOngletsImage() {
445,6 → 454,7
 
/**
* Accesseur pour la galerie d'images
*
* @return la galerie d'image
*/
public GalerieImageVue getGalerieImage() {
457,6 → 467,7
 
/**
* Accesseur pour le panneau "zoom"
*
* @return le panneau zoom
*/
public ZoomImageVue getZoomImage() {
465,6 → 476,7
 
/**
* Accesseur pour le panneau détails et mot clés
*
* @return le panneau détails et mots clés
*/
public Panel getDetailsEtMotsCles() {
473,6 → 485,7
/**
* Accesseur pour le booleen d'instanciation
*
* @return le booleen d'instanciation
*/
public static boolean isEstInstancie() {
481,6 → 494,7
 
/**
* Accesseur pour la panneau contenant le menu et les onglets images
*
* @return le panneauMenuEtOngletsImage
*/
public Panel getPanneauMenuEtOngletsImage() {
489,6 → 503,7
 
/**
* Accesseur pour le menu image
*
* @return the menuImageVue
*/
public MenuImageVue getMenuImageVue() {
497,6 → 512,7
 
/**
* Accesseur pour la barre d'outils
*
* @return the barreOutilsVue
*/
public BarreOutilsVue getBarreOutilsVue() {
505,6 → 521,7
 
/**
* Accesseur pour le panneau infos et métadonnées
*
* @return the metadonneesIptcExif
*/
public PanneauMetadonneesVue getMetadonneesIptcExif() {
513,6 → 530,7
 
/**
* Renvoie l'index du dernier onglet sélectionné
*
* @return l'index du dernier onglet
*/
public int getDernierIndexOnglet() {
521,49 → 539,40
/**
* Accesseur pour l'arbre des filtres
*
* @return l'arbre pour filtrer les mots clés
*/
public ArbreMotsClesFiltreVue getFiltreMotsCles()
{
public ArbreMotsClesFiltreVue getFiltreMotsCles() {
return filtreMotsCles ;
}
/**
* Accesseur pour la barre de recherche
*
* @return la barre de recherche pour filtrer les commentaires
*/
public BarreRechercheFiltreVue getFiltreCommentaires()
{
public BarreRechercheFiltreVue getFiltreCommentaires() {
return filtreCommentaires ;
}
/**
* Renvoie la vue sélectionné par l'utilisateur
*
* @return la vue selectionnée par l'utilisateur
*/
public VueListable getVueSelectionnee()
{
public VueListable getVueSelectionnee() {
Panel active = ongletsImage.getActiveTab() ;
if(active != zoomImage)
{
if(active == galerieImage)
{
if (active != zoomImage) {
if (active == galerieImage) {
return galerieImage ;
}
else
{
} else {
return listeImage ;
}
}
else
{
if(dernierIndexOnglet == 0)
{
} else {
if (dernierIndexOnglet == 0) {
return galerieImage ;
}
else
{
} else {
return listeImage ;
}
 
573,31 → 582,22
/**
* Renvoie l'identifiant de la vue en cours
*
* @return l'identifiant de la vue en cours de visualisation
*/
public String getIdVueSelectionnee()
{
public String getIdVueSelectionnee() {
Panel active = ongletsImage.getActiveTab() ;
if(active != zoomImage)
{
if(active == galerieImage)
{
if (active != zoomImage) {
if (active == galerieImage) {
return galerieImage.getId() ;
}
else
{
} else {
return listeImage.getId() ;
}
}
else
{
if(dernierIndexOnglet == 0)
{
} else {
if (dernierIndexOnglet == 0) {
return galerieImage.getId() ;
}
else
{
} else {
return listeImage.getId() ;
}
 
606,38 → 606,35
}
/**
* 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
* 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)
{
public void synchroniserDonneesZoomListeGalerie(Object o, Rafraichissable r) {
if(o instanceof Store) {
Store li = (Store)o ;
if(li.getCount() <= 0)
{
if (li.getCount() <= 0) {
aucuneSelection() ;
}
else
{
} else {
selection() ;
}
}
if(r != getGalerieImage())
{
if (r != getGalerieImage()) {
getGalerieImage().rafraichir(o,false);
}
if(r != getZoomImage())
{
if (r != getZoomImage()) {
getZoomImage().rafraichir(o,false);
}
if(r != getListeImage())
{
if (r != getListeImage()) {
getListeImage().rafraichir(o,false);
}
647,40 → 644,46
/**
* envoie au modèle une demande de mise a jour
* @param r la vue demandeuse de mise a jour
*
* @param r
* la vue demandeuse de mise a jour
*/
public void obtenirPhotoGalerie(Rafraichissable r)
{
public void obtenirPhotoGalerie(Rafraichissable r) {
masquerChargement() ;
getIModele().obtenirPhotoGalerie(r) ;
getIModele().obtenirNombrePhotoGalerie(r);
}
/**
* demande au modèle les métadonnées associées a une image
* @param r la vue demandeuse de mise a jour
* @param id l'identifiant de l'image
*
* @param r
* la vue demandeuse de mise a jour
* @param id
* l'identifiant de l'image
*/
public void obtenirMetadonnees(Rafraichissable r, String id)
{
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
*
* @param r
* la vue demandeuse de mise a jour
* @param id
* l'identifiant de l'image
*/
public void obtenirMotsClesId(Rafraichissable r, String id)
{
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
*
* @param r
* le raffraichissable qui a demandé la mise à jour
*/
public void obtenirArbreMotsCles(Rafraichissable r)
{
public void obtenirArbreMotsCles(Rafraichissable r) {
getIModele().obtenirArbreMotCle(r) ;
}
687,11 → 690,13
/**
* 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
*
* @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)
{
public void mettreAJourInfo(String commentaires, String date, String note) {
String ids[] = getVueSelectionnee().getIdSelectionnees() ;
getIModele().mettreAJourCacheImage(commentaires, date, note, ids) ;
699,30 → 704,34
}
/**
* 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
* 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)
{
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
* envoie au modèle une demande pour lancer le formulaire ou l'application
* d'upload
*/
public void uploaderImages()
{
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
* 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)
{
public void obtenirDonnes(String imgNum) {
obtenirMetadonnees(metadonneesIptcExif,imgNum) ;
obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), imgNum) ;
obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum) ;
730,8 → 739,11
/**
* 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
*
* @param noteVue
* le rafraichissable à qui est destiné cette information
* @param imgNum
* l'identifiant de l'image
*/
private void obtenirNote(Rafraichissable r, String imgNum) {
739,64 → 751,64
}
 
/**
* 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
* 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)
{
public void clicGalerieImage(int index, Element node, EventObject e) {
Record rd = getGalerieImage().getDView().getRecord(node) ;
String imgUrl = rd.getAsString("url_image");
String imgNum = rd.getAsString("num_image");
String[] imgXY = getIModele().obtenirTailleImage(
rd.getAsString("num_image"));
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
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)
{
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é
* 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)
{
public void clicListeImage(int rowIndex) {
Record rd = getListeImage().getSelectionModel().getSelected() ;
String imgUrl = rd.getAsString("url_image");
String imgNum = rd.getAsString("num_image");
String[] imgXY = getIModele().obtenirTailleImage(
rd.getAsString("num_image"));
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
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)
{
public void doubleClicListeImage(int rowIndex) {
clicListeImage(rowIndex) ;
getOngletsImage().setActiveTab(2);
}
804,17 → 816,17
/**
* envoie une demande de mise a jour des données au modèle
*/
public void rafraichirToutesVues()
{
public void rafraichirToutesVues() {
obtenirPhotoGalerie(getIModele());
}
/**
* montre le menu au coordonnées indiquées
* @param e l'objet source de l'évenement
*
* @param e
* l'objet source de l'évenement
*/
public void montrerContextMenu(EventObject e)
{
public void montrerContextMenu(EventObject e) {
menuImageVue.showAt(e.getXY()) ;
}
821,17 → 833,17
/**
* appelé lors du double clic sur l'image agrandie
*/
public void doubleClicZoomImage()
{
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é
*
* @param arg
* le nom du bouton qui a cliqué
*/
public void clicBoutonZoomImage(String arg)
{
public void clicBoutonZoomImage(String arg) {
Store st ;
int selected ;
839,25 → 851,20
Record nRec = null ;
// tout d'abord on obtient les index selectionnés suivant la vue
if(getVueSelectionnee() == galerieImage)
{
if (getVueSelectionnee() == galerieImage) {
DataView dv = getGalerieImage().getDView();
st = getGalerieImage().getSt();
if(st.getCount() <= 0)
{
if (st.getCount() <= 0) {
return ;
}
selected = st.indexOf(dv.getSelectedRecords()[0]);
storeIndex = dv.indexOf(selected);
}
else
{
} else {
st = listeImage.getSt() ;
if(st.getCount() <= 0)
{
if (st.getCount() <= 0) {
return ;
}
865,8 → 872,7
storeIndex = selected ;
}
if(arg.equals("prev"))
{
if (arg.equals("prev")) {
// si la photo séléctionnée est la première, on passe a la
// dernière
if (selected == 0) {
873,18 → 879,14
storeIndex = st.getCount() - 1 ;
nRec = st.getAt(storeIndex);
}
else
{
} else {
storeIndex = storeIndex - 1 ;
nRec = st.getAt(storeIndex);
}
}
if(arg.equals("suiv"))
{
if (arg.equals("suiv")) {
// si la photo selectionnée est la dernière on passe a la
// première
if (selected == st.getCount() - 1) {
891,51 → 893,46
storeIndex = 0 ;
nRec = st.getAt(0);
}
else
{
} else {
storeIndex = storeIndex + 1 ;
nRec = st.getAt(storeIndex);
}
}
if(nRec != null)
{
if (nRec != null) {
String imgUrl = nRec.getAsString("url_image");
String[] imgXY = getIModele().obtenirTailleImage(nRec.getAsString("num_image")) ;
String[] infosImage = {imgUrl , imgXY[0] , imgXY[1] } ;
String imgNum = nRec.getAsString("num_image");
String[] imgXY = getIModele().obtenirTailleImage(
nRec.getAsString("num_image"));
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum };
getZoomImage().rafraichir(infosImage,false);
if(getGalerieImage().isRendered())
{
if (getGalerieImage().isRendered()) {
getGalerieImage().getDView().select(storeIndex);
}
if(getListeImage().isRendered())
{
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
*
* @param string
* le nom de la vue qui doit être synchronisee
*/
public void synchroniserSelection(String string) {
if(string.equals("galerie") && getDernierIndexOnglet() != 2)
{
if (string.equals("galerie") && getDernierIndexOnglet() != 2) {
Record[] sel = getGalerieImage().getDView().getSelectedRecords() ;
getListeImage().selectionnerEnregistrements(sel) ;
}
if(string.equals("liste") && getDernierIndexOnglet() != 0)
{
if (string.equals("liste") && getDernierIndexOnglet() != 0) {
Record[] sel = getListeImage().getSelectionModel().getSelections() ;
int[] ids = new int[sel.length] ;
951,36 → 948,28
}
 
/**
* fait une demande de suppression des images (en local et en distant)
* des images selectionnees
* fait une demande de suppression des images (en local et en distant) des
* images selectionnees
*/
public void supprimerImages() {
String[] ids = null ;
if(dernierIndexOnglet == 0)
{
if (dernierIndexOnglet == 0) {
ids = getGalerieImage().getIdSelectionnees() ;
}
else
{
} else {
ids = getListeImage().getIdSelectionnees() ;
}
if(ids.length > 0)
{
if (ids.length > 0) {
if(com.google.gwt.user.client.Window
.confirm("Supprimer les images selectionnees ?"))
{
.confirm("Supprimer les images selectionnees ?")) {
masquerChargement() ;
getIModele().supprimerImages(ids) ;
aucuneSelection() ;
}
}
else
{
} else {
Window.alert("Impossible de supprimer : aucune image selectionnee") ;
}
987,12 → 976,13
}
 
/**
* desactive les onglets de metadonnees et de zoom (dans le cas ou rien n'est selectionne)
* 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)
{
if (getListeImage().getSelectionModel().getCount() <= 0
&& getGalerieImage().getDView().getSelectionCount() <= 0) {
getZoomImage().disable() ;
getMetadonneesIptcExif().desactiverPanneau() ;
getZoomImage().desactiverPanneau() ;
1002,12 → 992,12
}
/**
* reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il n'y en avait pas)
* reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il
* n'y en avait pas)
*/
public void selection() {
if(!isSelection())
{
if (!isSelection()) {
getMetadonneesIptcExif().activerPanneau() ;
getZoomImage().activerPanneau() ;
getZoomImage().enable() ;
1016,16 → 1006,24
}
 
/**
* 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
* 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)
{
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");
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);
1032,16 → 1030,14
mn.addListener(new MenuListenerAdapter() {
public void onItemClick(BaseItem item, EventObject e)
{
if(item.equals(suppN))
{
getMetadonneesIptcExif().getPanneauMotsCles().supprimerNoeud(n) ;
public void onItemClick(BaseItem item, EventObject e) {
if (item.equals(suppN)) {
getMetadonneesIptcExif().getPanneauMotsCles()
.supprimerNoeud(n);
}
if(item.equals(ajoutN))
{
getMetadonneesIptcExif().getPanneauMotsCles().ajouterNoeud(n) ;
if (item.equals(ajoutN)) {
getMetadonneesIptcExif().getPanneauMotsCles().ajouterNoeud(
n);
}
}
});
1051,9 → 1047,13
}
/**
* 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é
* 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) {
1062,10 → 1062,14
}
 
/**
* 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
* 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) {
1075,12 → 1079,15
}
/**
* 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
* 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)
{
public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
getIModele().ajouterMotCleDansArbre(n, arbreMC) ;
filtres.getMotsClesFiltre().rafraichir(n, false) ;
1087,9 → 1094,13
}
 
/**
* 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
* 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) {
1099,9 → 1110,13
}
 
/**
* 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
* 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) {
1111,9 → 1126,13
}
/**
* 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
* 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) {
1126,12 → 1145,15
*/
public void initialiserMotsCleCoches() {
obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), getGalerieImage().getIdSelectionnees()[0]) ;
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
*
* @param pageCourante
* le numéro de page à affciher
*/
public void changerNumeroPage(int pageCourante) {
1148,10 → 1170,11
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*
* @param nouvelleTaillePage
* la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage)
{
public void changerTaillePage(int nouvelleTaillePage) {
// on met le message d'attente
masquerChargement() ;
1159,19 → 1182,26
getIModele().changerTaillePage(nouvelleTaillePage) ;
// et on met à jour la taille de page dans les barres d'outils
getGalerieImage().getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
getListeImage().getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
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
*
* @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)
{
public void changerPageMaxEtCourante(int pageMax, int pageEncours,
int taillePage, int nbElement) {
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
getGalerieImage().getToolBarVue().rafraichir(pages, false) ;
1180,102 → 1210,258
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
* Recherche l'élement actuellement affiché et affiche son message de
* chargement
*/
public void masquerChargement()
{
public void masquerChargement() {
ExtElement masked = Ext.get(getIdVueSelectionnee()) ;
if(masked != null && !masked.isMasked())
{
if (masked != null && !masked.isMasked()) {
masked.mask("Chargement",true) ;
}
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
* Recherche l'élement actuellement affiché et retire son message de
* chargement si l'était affiché
*/
public void demasquerChargement()
{
public void demasquerChargement() {
ExtElement masked = Ext.get(getIdVueSelectionnee()) ;
if(masked != null && masked.isMasked())
{
if (masked != null && masked.isMasked()) {
masked.unmask() ;
}
}
 
public void afficherMenuId()
{
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]
* 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()
{
public String[][] renvoyerFiltres() {
String[][] valeursFiltres = filtres.renvoyerValeursAFiltrer() ;
for (int i = 0; i < valeursFiltres.length; i++) {
if(valeursFiltres[i].equals(null))
{
Window.alert("Le filtre "+i+" est nul") ;
}
else
{
if(valeursFiltres[i][0].equals(null))
{
Window.alert("Le nom du filtre "+i+" est nul") ;
}
if(valeursFiltres[i][1].equals(null))
{
Window.alert("La valeur du filtre "+i+" est nulle") ;
}
}
}
 
return valeursFiltres ;
}
/**
* Indique si les filtres ont changés depuis la dernière requête
* (il faut faire un OR sur le résultat de toutes les fonctions
* renvoyerEtatFiltre s'il y a plus d'un filtre)
* 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()
{
public boolean getEtatFiltres() {
return (filtres.renvoyerEtatFiltre());
}
/**
* Accesseur pour le panneau de droite contenant les filtres
*
* @return le panneau contenant les filtres
*/
public PanneauFiltresVues getPanneauFiltres()
{
public PanneauFiltresVues getPanneauFiltres() {
return filtres ;
}
public void ajouterListeners()
/**
* ajoute les images séléctionnées dans la vue courante au tampon
*/
public void ajouterImagesSelection() {
String[] ids = getVueSelectionnee().getIdSelectionnees();
String id = "";
for (int i = 0; i < ids.length; i++) {
id += " - " + ids[i];
}
getIModele().ajouterImagesSelection(ids);
 
Window.alert(ids.length + " image(s) ajoutées au tampon ");
 
}
/**
* Affiche les ids des images contenues dans le tampon
*/
public void afficherIdSelectionImages() {
 
Window.alert("Contenu du tampon : " + getIModele().renvoyerSelection());
 
}
/**
* Renvoie les ids des images contenues dans le tampon en une seule string
* @return une string de la forme id1, id2, id3
*/
public String renvoyerSelection() {
return getIModele().renvoyerSelection();
}
/**
* Vide le tampon d'images
*/
public void viderSelection() {
 
getIModele().viderSelection();
Window.alert("Le tampon a été vidé ");
 
}
 
/**
* Fonction appelée lors du drag 'n drop d'une image sur une observation
* @param source la source du drag
* @param e l'objet sur lequel on a fait le drop
* @param data les données
* @return une booleen indiquant le succès ou l'échec de l'opération
*/
public boolean lierImagesDD(DragSource source, EventObject e, DragData data) {
// on peut convertir directement les données car on a testé avant le type de données
GridDragData gdd = (GridDragData)data ;
// les ids des images sont initialisées
String idsImg = "" ;
// on obtient la liste des selections dans la source
Record[] aLier = gdd.getSelections() ;
for (int i = 0; i < aLier.length; i++)
{
/*ongletsImage.addListener(new TabPanelListenerAdapter() {
// on les concatènes en une seule chaine
idsImg += aLier[i].getAsString("id_image")+"," ;
}
 
public boolean doBeforeTabChange(TabPanel source, Panel newPanel,
Panel oldPanel) {
MiniListeObservationVue mv = getMetadonneesIptcExif().getMiniListeObservation() ;
// on cherche quel est la ligne sur laquelle on a fait le drop dans la la liste des observations
int index = mv.getView().findRowIndex(e) ;
Record rddrop = mv.getStore().getRecordAt(index) ;
if(newPanel != null && newPanel.equals(getZoomImage()))
// SI l'enregistrement existe bel et bien
if(rddrop != null)
{
if(getGalerieImage() != null && getGalerieImage().getIdSelectionnees().length <= 0)
String idObs = rddrop.getAsString("id_obs")+"," ;
// on lie les observations
lierImagesObservation(idObs, idsImg) ;
}
return true ;
}
/**
* Fonction appelée lors du drag 'n drop d'une observation sur une image
* @param source la source du drag
* @param e l'objet sur lequel on a fait le drop
* @param data les données
* @return une booleen indiquant le succès ou l'échec de l'opération
*/
public boolean lierObsDD(DragSource source, EventObject e, DragData data, String idDest) {
// on peut convertir directement les données car on a testé avant le type de données
GridDragData gdd = (GridDragData)data ;
// les ids des images sont initialisées
String idsObs = "" ;
// on obtient la liste des selections dans la source
Record[] aLier = gdd.getSelections() ;
for (int i = 0; i < aLier.length; i++)
{
Window.alert("Aucune image selectionnée pour l'affichage !") ;
aucuneSelection() ;
return false ;
// on les concatènes en une seule chaine
idsObs += aLier[i].getAsString("id_obs")+"," ;
}
Record rddrop = null ;
// si la destination est la galerie d'images
if(idDest.equals(getGalerieImage().getId()))
{
GalerieImageVue gv = getGalerieImage() ;
// alors l'élément sur lequel on a fait le drop n'est pas le bon
int index = gv.getDView().indexOf(e.getTarget()) ;
Element el = e.getTarget() ;
// alors on cherche son parent tant que celui-ci n'est pas présent dans la dataview
while(index == -1 && el != null)
{
index = gv.getDView().indexOf(el) ;
el = (Element) el.getParentElement() ;
}
return true ;
// si on l'a trouvé, on obtient l'enregistrement qui correspond
if(index != -1)
{
rddrop = gv.getSt().getAt(index) ;
}
 
public void onTabChange(TabPanel source, Panel tab) {
// TODO Auto-generated method stub
}
// si la destination est la liste d'images
if(idDest.equals(getListeImage().getId()))
{
// on obtient directement l'enregistrement correspondant à l'élément sur lequel on a fait le drop
ListeImageVue lv = getListeImage() ;
int index = lv.getView().findRowIndex(e) ;
rddrop = lv.getSt().getAt(index) ;
}
 
public void onActivate(Panel panel) {
// TODO Auto-generated method stub
// si on a bien obtenu un enregistrement
if(rddrop != null)
{
// on récupère l'id de l'image et alors on appelle la fonction de liaison
String idImg = rddrop.getAsString("id_image")+"," ;
lierImagesObservation(idsObs, idImg) ;
return true ;
}
}) ;*/
// si la destination est l'image zoomée
if(idDest.equals(getZoomImage().getId()))
{
// on obtient directement l'id correspondant
ZoomImageVue zv = getZoomImage() ;
String idImg = zv.getIdImage() ;
lierImagesObservation(idsObs, idImg) ;
return true ;
}
return false ;
}
 
/**
* Lie une ou plusieurs images à une ou plusieurs observations
* @param idsObs les identifiants des observations séparés par des ","
* @param idsImg les identifiants des images séparés par des ","
*/
public void lierImagesObservation(String idsObs, String idsImg)
{
// TODO: faire une vraie liaison dans la base de données avec des vraies observations
getIModele().lierImagesObervations(idsObs,idsImg) ;
//Window.alert("Les observations suivantes : "+idsObs+" seront liées aux images suivantes : "+idsImg) ;
}
 
}
/trunk/src/org/tela_botanica/client/image/ImageModele.java
2,6 → 2,7
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
8,6 → 9,7
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ImageCarnet;
import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;
import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeImageCarnet;
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
27,8 → 29,8
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
* Modèle d'accès aux données pour les images.
* C'est un singleton
* Modèle d'accès aux données pour les images. C'est un singleton
*
* @author aurelien
*
*/
35,7 → 37,8
public class ImageModele implements Rafraichissable {
/**
* Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
* Booleen indiquant si le médiateur est instancié (l'instance doit être
* unique donc le booleen est static)
*/
private static boolean estInstancie = false ;
63,7 → 66,8
*/
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
* Le store contenant les données à afficher, que le modèle transmet au
* médiateur quand il le demande
*/
private Store st = null ;
/**
89,15 → 93,21
private int nbElements = 0 ;
/**
* "Presse papier" pour les images qui permet de garder en mémoire une
* sélection
*/
private Vector<String> selectionImages = new Vector<String>(0);
 
/**
* Retourne une instance de manière unique
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
* @return l'instance du modèle
*/
static ImageModele Instance(ImageMediateur im)
{
static ImageModele Instance(ImageMediateur im) {
// si le modèle n'est pas encore instancié
if(!estInstancie)
{
if (!estInstancie) {
// on en crée un nouveau
estInstancie = true ;
thisModele = new ImageModele(im);
110,7 → 120,9
/**
* Le constructeur est privé et seule la méthode instance y accède
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
private ImageModele(ImageMediateur im) {
120,30 → 132,51
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur()
{
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
*
* @param r
* le rafraichissable auxquel on enverra les données
*/
public void obtenirPhotoGalerie(Rafraichissable r)
{
public void obtenirNombrePhotoGalerie(Rafraichissable r) {
String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
int tailleFiltres = motsClesFiltres.length ;
int tailleFiltres = valeursFiltres.length;
String[][] criteres = new String[tailleFiltres+1][2] ;
String[][] criteres2 = new String[tailleFiltres+2][2] ;
String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ;
String[] utilisateur = { "ci_ce_utilisateur",
"" + getIMediateur().getIdentifiant() };
criteres[0] = utilisateur ;
 
for (int i = 0; i < valeursFiltres.length; i++) {
criteres[i + 1] = valeursFiltres[i];
}
 
// on les crée un DAO auquel on les transmet et qui demande le nombre
// d'images correspondantes (pour les pages)
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
niaDAO.obtenirNombreImages(this, criteres);
}
public void obtenirPhotoGalerie(Rafraichissable r)
{
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
int tailleFiltres = valeursFiltres.length;
String[][] criteres2 = new String[tailleFiltres + 2][2];
String[] limite = {"ci_limite" ,""+taillePage } ;
String[] taillePage = {"ci_numero_page",""+pageEncours} ;
150,28 → 183,22
criteres2[0] = limite ;
criteres2[1] = taillePage ;
for (int i = 0 ; i < motsClesFiltres.length; i++) {
criteres[i+1] = motsClesFiltres[i] ;
criteres2[i+2] = motsClesFiltres[i] ;
for (int i = 0; i < valeursFiltres.length; i++) {
criteres2[i + 2] = valeursFiltres[i];
}
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this) ;
niaDAO.obtenirNombreImages(this, criteres) ;
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
// 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
* 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()
{
public void uploaderImages() {
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this) ;
IuADaO.choisirMethodeUpload() ;
}
178,44 → 205,47
/**
* Met à jour la liste des images à partir d'un objet
* @param o la nouvelle liste d'image
*
* @param o
* la nouvelle liste d'image
*/
public void rafraichirListeImage(Object o)
{
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
*
* @param o
* le nouvel arbre de mots clés
*/
public void rafraichirArbreMotsCles(Object o)
{
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
* 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)
{
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
* 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)
{
public void obtenirMetadonnees(Rafraichissable r, String id) {
ImageCarnet im = (ImageCarnet)cacheImage.get(id) ;
Object meta[] = new Object[3] ;
227,13 → 257,15
}
/**
* 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
* 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)
{
public void obtenirMotsClesId(Rafraichissable r, String id) {
ImageCarnet im = cacheImage.get(id) ;
String motsClesId = im.getMotsCles() ;
String[] motsClesIdTab = motsClesId.split(",") ;
242,16 → 274,19
}
/**
* 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
* 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++)
{
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) ;
262,20 → 297,21
/**
* 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é
*
* @param text
* le mot clé
* @param id
* l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id)
{
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
* 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()
{
public void mettreAJourBaseDeDonneesListeImageCarnet() {
ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
liDaO.SynchroniserBaseDeDonnees(cacheImage);
282,28 → 318,29
}
/**
* 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
* 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)
{
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
* 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)
{
public void supprimerImages(String[] ids) {
String rids[] = new String[ids.length] ;
ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this) ;
for (int i = 0; i < ids.length; i++)
{
for (int i = 0; i < ids.length; i++) {
String key = ids[i] ;
ImageCarnet ic = cacheImage.get(key) ;
rids[i] = ic.getId() ;
311,33 → 348,29
cacheImage.remove(key) ;
}
if(rids.length != 0)
{
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
* 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)
{
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
// si l'on a reçu une liste d'images
if(nouvelleDonnees instanceof ListeImageCarnet)
{
if (nouvelleDonnees instanceof ListeImageCarnet) {
ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ;
Object[][] photoData = new Object[data.size()][8];
Object[][] photoData = new Object[data.size()][9];
int i = 0 ;
if(data.size() == 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();)
{
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() ;
347,6 → 380,7
photoData[i][5] = im.getMUrl() ;
photoData[i][6] = im.getLUrl() ;
photoData[i][7] = im.getNote() ;
photoData[i][8] = im.getId();
i++ ;
}
360,7 → 394,10
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};
FieldDef defIdImage = new IntegerFieldDef("id_image");
FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage, defIdImage };
RecordDef rd = new RecordDef(defTab) ;
final MemoryProxy dataProxy = new MemoryProxy(photoData);
376,17 → 413,15
// 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)
{
// 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)
{
if (nouvelleDonnees instanceof JSONArray) {
// alors on a reçu les informations sur les mots clés
JSONArray reponse = (JSONArray)nouvelleDonnees ;
393,8 → 428,7
final int taillemax = reponse.size();
// si le tableau est vide
if(taillemax == 0)
{
if (taillemax == 0) {
// on crée un arbre vide
TreeNode root = new TreeNode() ;
root.setId("racine") ;
405,31 → 439,31
}
// pour chacun des élements du tableau
for (int j = 0; j < taillemax ; j++)
{
for (int j = 0; j < taillemax; j++) {
// on extrait les élements du tableau
if(reponse.get(j).isObject() != null)
{
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 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"))
{
// 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
} 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) ;
443,22 → 477,27
}
// 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
// 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[])
{
// 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
// 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]) ;
getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
taillePage, pages[0]);
obtenirPhotoGalerie(this) ;
}
}
465,10 → 504,8
/**
* Affiche les paires / valeur de tous les mots clés stockés
*/
public void afficherMotsCles()
{
for(Iterator<String> it = motsCles.keySet().iterator() ; it.hasNext() ;)
{
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);
476,17 → 513,20
}
 
/**
* 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
* 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]))
{
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) ;
498,33 → 538,37
rafraichirArbreMotsCles(arbreMC) ;
}
/**
* Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la base de données
* Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la
* base de données
*/
public void initialiserArbreMotsCles()
{
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
* 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)
{
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
* 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)
{
public void ajouterMotCleDansArbre(TreeNode n,
com.gwtext.client.data.Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
532,30 → 576,30
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
if (!id.equals("racine")) {
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
}
else
{
} else {
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String nouveauMotCle = "&identifiant="+getIdentifiant()+"&motcle="+motCle+"&id="+id+"&parent="+parentId ;
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
* 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)
{
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
567,13 → 611,15
}
 
/**
* 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
* 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)
{
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
582,31 → 628,31
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
if (!id.equals("racine")) {
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
}
else
{
} else {
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
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
* 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)
{
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
613,43 → 659,46
String motCle = usObj[0] ;
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
if (!id.equals("racine")) {
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
}
else
{
} else {
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
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
* 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)
{
public void changerNumeroPage(int nouvellePageCourante) {
pageEncours = nouvellePageCourante ;
obtenirPhotoGalerie(this) ;
obtenirNombrePhotoGalerie(this);
}
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* 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
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
// 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) ;
660,15 → 709,17
/**
* Recalcule la page en cours lors du changement du nombre d'élements
* @param nbElements le nombre d'élements total
*
* @param nbElements
* le nombre d'élements total
* @return la nouvelle page encours
*/
public int calculerPageCourante(int nbElements)
{
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) ;
double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
* (1.0 * nouvelNbPages);
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante) ;
680,20 → 731,21
/**
* Change la taille de page et recalcule la page encours
* @param nouvelleTaillePage la nouvelle taille de page à utiliser
*
* @param nouvelleTaillePage
* la nouvelle taille de page à utiliser
*/
public void changerTaillePage(int nouvelleTaillePage)
{
public void changerTaillePage(int nouvelleTaillePage) {
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
obtenirPhotoGalerie(this) ;
obtenirNombrePhotoGalerie(this);
}
/**
* Notifie le mediateur que l'upload ou le download est termine et qu'il faut rafraichir les vues avec les nouvelles données
* 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()
{
public void requeteTerminee() {
getIMediateur().demasquerChargement() ;
getIMediateur().rafraichirToutesVues() ;
}
700,6 → 752,7
 
/**
* Obtient l'identifiant de l'utilisateur auprès du médiateur
*
* @return id de l'utilisateur
*/
public String getIdentifiant() {
709,7 → 762,9
 
/**
* renvoie la taille d'une image grâce à son identifiant
* @param id l'identifiant de l'image
*
* @param id
* l'identifiant de l'image
* @return un tableau contenant la longueur et la hauteur de l'image
*/
public String[] obtenirTailleImage(String id) {
721,8 → 776,11
/**
* 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
*
* @param r
* le rafraichissable demandeur de l'information
* @param id
* l'identifiant del'image
*/
public void obtenirNote(Rafraichissable r, String id) {
732,6 → 790,7
/**
* Accesseur pour la configuration en cours d'utilisation
*
* @return la configuration
*/
public Configuration getConfig() {
739,4 → 798,52
return config ;
}
/**
* Ajoute des images à la selection en cours
*
* @param ids
* les identifiants des images à ajouter
*/
public void ajouterImagesSelection(String[] ids) {
 
for (int i = 0; i < ids.length; i++) {
 
selectionImages.add(ids[i]);
}
}
 
/**
* Vide la selection en cours
*/
public void viderSelection() {
selectionImages.clear();
}
 
public String renvoyerSelection() {
 
String selection = "";
if(selectionImages.size() <= 0)
{
selection += "-255" ;
}
else
{
for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
String idEncours = it.next();
selection += idEncours + ",";
}
}
 
return selection;
}
 
public void lierImagesObervations(String idsObs, String idsImg) {
LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
}
 
}
/trunk/src/org/tela_botanica/client/vues/pageToolBarVue.java
20,9 → 20,10
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
* Barre de pagination asynchrone avec filtrage des touches et accès directs et
* séquentiels à une page
*
* @author aurelien
*
*/
42,7 → 43,8
*/
private ToolbarButton suivPage = new ToolbarButton() ;
/**
* Numéro de la page courante (attention, commence à zéro pour des raisons pratiques)
* Numéro de la page courante (attention, commence à zéro pour des raisons
* pratiques)
*/
private int pageCourante = 0 ;
/**
68,53 → 70,56
/**
* Affichage de "sur pageTotale "
*/
private ToolbarTextItem surTotalPage = new ToolbarTextItem(" 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
* 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 ") ;
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) ;
private ToolbarTextItem intervalleElements = new ToolbarTextItem("Images "
+ pageCourante * taillePage + " sur " + nbElement);
 
/**
* retourne le mediateur associe à la barre
*/
public ImageMediateur getImediateur()
{
public ImageMediateur getImediateur() {
return iMediateur ;
}
/***
/***************************************************************************
* constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private pageToolBarVue()
{
private pageToolBarVue() {
super() ;
}
/**
* constructeur avec paramètres
* @param im le médiateur à associer à la barre
*
* @param im
* le médiateur à associer à la barre
*/
public pageToolBarVue(ImageMediateur im)
{
public pageToolBarVue(ImageMediateur im) {
super() ;
iMediateur = im ;
// on dispose un peu de texte et quelques espaces pour séparer les éléments
// on dispose un peu de texte et quelques espaces pour séparer les
// éléments
addButton(prevPage) ;
addSpacer() ;
addItem(page) ;
132,13 → 137,14
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());
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
// 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>");
+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
tp.compile();
selecteurTaillePage.setTpl(tp) ;
150,7 → 156,8
selecteurTaillePage.setWidth(50) ;
addItem(nbElemParPage) ;
// on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
// on remplit l'espace pour que l'intervalle d'élement se place à droite
// de la barre
addFill() ;
addItem(intervalleElements) ;
addSpacer() ;
160,19 → 167,17
}
/**
* ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination
* ajoute les différents listeners nécessaires au bon fonctionnement des
* éléments de la barre de pagination
*/
private void ajouterListeners()
{
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)
{
if (pageCourante > 0) {
// on décrémente la page courante de 1
pageCourante -- ;
// on rafraichit l'affichage
186,12 → 191,10
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)
{
if (pageCourante < pageTotale - 1) {
// on incrémente la page courante de 1
pageCourante ++ ;
// on rafraichit l'affichage
205,38 → 208,38
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)
{
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()) ;
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)
{
// 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
// 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
} else {
// sinon on reaffiche l'ancien numero de page sans rien
// changer
rafraichirNumeroPage() ;
champPage.focus(true) ;
}
243,7 → 246,6
}
}
public void onFocus(Field field) {
champPage.focus(true) ;
251,27 → 253,26
});
// pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
// 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()))
{
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)
{
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
} else {
// sinon on remet le numero de page correct et on annule
// l'évenement
rafraichirNumeroPage() ;
e.stopEvent() ;
}
282,15 → 283,15
// 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) ;
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)
{
if (nouvelleTaillePage != taillePage) {
// on la change
changerTaillePage(nouvelleTaillePage) ;
}
302,43 → 303,43
}
/**
* Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments
* à partir des variables de classes
* Met à jour les affichage sur les numéros de pages et d'intervalle
* d'éléments à partir des variables de classes
*/
public void rafraichirNumeroPage()
{
public void rafraichirNumeroPage() {
surTotalPage.setText(" sur "+pageTotale) ;
if(nbElement == 0)
{
if (nbElement == 0) {
champPage.setValue(""+(0)) ;
// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
// on met simplement à jour l'intervalle qui contient toujours le
// même nombre d'éléments
intervalleElements.setText("Images 0 - 0 sur 0") ;
}
else
{
} 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) ;
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);
}
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
*
* @param nouvellePageCourante
* la nouvelle page en cours
*/
public void changerPageCourante(int nouvellePageCourante)
{
public void changerPageCourante(int nouvellePageCourante) {
pageCourante = nouvellePageCourante ;
}
349,8 → 350,7
boolean repandreRaffraichissement) {
// si on reçoit un tableau de int
if(nouvelleDonnees instanceof int[])
{
if (nouvelleDonnees instanceof int[]) {
int [] page = (int[])nouvelleDonnees ;
// le premier élement est le nombre de pages totales
pageTotale = page[0] ;
361,11 → 361,12
// 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
// 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)
{
if (pageCourante >= pageTotale && pageCourante != 0) {
pageCourante = pageTotale - 1 ;
// le cas échéant on en notifie le médiateur
getImediateur().changerNumeroPage(pageCourante) ;
372,16 → 373,18
}
}
// enfin on rafraichit les informations affichées à partir des nouvelles variables de classes mises à jour
// 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
*
* @return un tableau de tableau de string qui contient les différentes
* taille de pages
*/
public String[][] getNbPages()
{
public String[][] getNbPages() {
String[][] pages = {{"200"},{"100"},{"50"},{"20"},{"10"}} ;
return pages ;
388,9 → 391,12
}
 
/**
* 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())
* 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) {
399,8 → 405,11
}
/**
* Selectionne la valeur correspond à celle passée en paramètre dans la combobox (si elle existe)
* @param nouvelleTaillePage la nouvelle taille de page
* 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) {
/trunk/src/org/tela_botanica/client/vues/PanneauFiltresVues.java
8,9 → 8,9
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
*
*/
37,6 → 37,11
private DateFiltreVue dateFiltreVues = null ;
/**
* Recherche par contenu du tampon
*/
private SelectionFiltreVue selectionFiltreVue = null;
 
/**
* Bouton de validation
*/
private Button valider = null ;
45,17 → 50,17
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
*/
@SuppressWarnings("unused")
private PanneauFiltresVues()
{
private PanneauFiltresVues() {
super() ;
}
/**
* Constructeur avec arguments
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public PanneauFiltresVues(ImageMediateur im)
{
public PanneauFiltresVues(ImageMediateur im) {
super("Rechercher des images") ;
iMediateur = im ;
68,6 → 73,9
dateFiltreVues = new DateFiltreVue(im) ;
add(dateFiltreVues) ;
selectionFiltreVue = new SelectionFiltreVue(im);
add(selectionFiltreVue);
 
motsClesFiltres = new ArbreMotsClesFiltreVue(im) ;
add(motsClesFiltres) ;
90,38 → 98,47
/**
* Accesseur pour le filtre des mots clés
*
* @return le filtre des mots clés
*/
public ArbreMotsClesFiltreVue getMotsClesFiltre()
{
public ArbreMotsClesFiltreVue getMotsClesFiltre() {
return motsClesFiltres ;
}
/**
* Accesseur pour le filtre par commentaire
*
* @return le filtre des commentaires
*/
public BarreRechercheFiltreVue getBarreRecherche()
{
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() ) ;
return (motsClesFiltres.renvoyerEtatFiltre()
|| commFiltresVues.renvoyerEtatFiltre()
|| dateFiltreVues.renvoyerEtatFiltre()
|| selectionFiltreVue.renvoyerEtatFiltre());
}
/**
* Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre", "valeur"
* 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() } ;
public String[][] renvoyerValeursAFiltrer() {
String[][] filtres = { motsClesFiltres.renvoyerValeursAFiltrer(),
commFiltresVues.renvoyerValeursAFiltrer(),
dateFiltreVues.renvoyerValeursAFiltrer(),
selectionFiltreVue.renvoyerValeursAFiltrer() };
return filtres ;
}
 
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
1,7 → 1,5
package org.tela_botanica.client.vues;
 
 
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
21,8 → 19,9
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é
* Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
* clés cochables et réorganisables à volonté
*
* @author aurelien
*
*/
50,20 → 49,24
*/
private Button valider = null ;
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par des virgules
* 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é)
* (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
* 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
* Booléen d'évènement qui sert à savoir si on est en train de modifier un
* noeud
*/
private boolean modifNoeud = false ;
/**
79,17 → 82,17
* Constructeur sans paramètre (privé car interdit d'utilisation)
*/
@SuppressWarnings("unused")
private ArbreMotsClesVue()
{
private ArbreMotsClesVue() {
super() ;
}
/**
* Constructeur avec paramètre
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesVue(ImageMediateur im)
{
public ArbreMotsClesVue(ImageMediateur im) {
// on crée le panel
super("Mots clés") ;
this.setLayout(new VerticalLayout());
133,6 → 136,7
/**
* Acesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
private ImageMediateur GetIMediateur() {
143,6 → 147,7
/**
* Acesseur pour l'arbre des mots clés
*
* @return le panel contenant l'arbre
*/
public TreePanel getArbreMotsCles() {
151,6 → 156,7
 
/**
* Accesseur pour l'éditeur
*
* @return l'éditeur associé à l'arbre
*/
public TreeEditor getTe() {
159,6 → 165,7
 
/**
* Acesseur pour le TextField associé à l'éditeur
*
* @return le champ texte associé à l'éditeur
*/
public TextField getTfEdit() {
168,8 → 175,7
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners()
{
private void ajouterListeners() {
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
// gestion du clic sur un noeud
191,8 → 197,7
public void onDblClick(TreeNode node, EventObject e) {
modifNoeud = true ;
if(! node.getId().equals("racine"))
{
if (!node.getId().equals("racine")) {
te.startEdit(node);
}
}
208,20 → 213,21
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()) ;
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()) ;
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 ;
}
230,10 → 236,11
}
// gestion du déplacement d'un noeud
public void onMoveNode(Tree tree, TreeNode node, TreeNode oldParent, TreeNode newParent,int index)
{
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()) ;
GetIMediateur().deplacerMotCleDansArbre(node,
getArbreMotsCles().getTree());
}
}) ;
247,20 → 254,25
// on vide les mots clés en cours
motsClesEnCours = "" ;
// pour chaque noeud à partir de la racine
getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
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()) ;
// 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]) ;
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
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots
// clés en cours
motsClesEnCours += usObject[1]+"," ;
}
269,8 → 281,10
});
// 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()) ;
// 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());
}
}) ;
287,22 → 301,23
 
/**
* Supprime un noeud de l'arbre
* @param n le noeud à supprimer
*
* @param n
* le noeud à supprimer
*/
public void supprimerNoeud(TreeNode n)
{
public void supprimerNoeud(TreeNode n) {
// si ça n'est pas la racine (qu'on ne peut pas supprimer)
if(!n.getId().equals(getArbreMotsCles().getRootNode().getId()))
{
if (!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
// 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") ;
}
}
309,10 → 324,11
/**
* Ajoute un noeud dans l'arbre au parent donné
* @param parent le futur parent du noeud à ajouter
*
* @param parent
* le futur parent du noeud à ajouter
*/
public void ajouterNoeud(TreeNode parent)
{
public void ajouterNoeud(TreeNode parent) {
// on met l'ajout du noeud à vrai
ajoutNoeud = true ;
333,56 → 349,58
// 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é
// 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())
{
public void gererClicNoeud(TreeNode node) {
if (node.getUI().isChecked()) {
node.getUI().toggleCheck(false) ;
}
else
{
} 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
* 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)
{
public void cocherMotsCles(final String[] motsClesIds) {
if (getArbreMotsCles() != null
&& getArbreMotsCles().getRootNode() != null) {
// à partir de la racine
getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
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() ;
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) ;
if (nodeId.equals(motsClesIds[i])) {
getArbreMotsCles().getNodeById(nodeId)
.getUI().toggleCheck(true);
return true ;
}
getArbreMotsCles().getNodeById(node.getId()).getUI().toggleCheck(false) ;
getArbreMotsCles().getNodeById(node.getId())
.getUI().toggleCheck(false);
}
// et on passe au suivant
return true;
394,18 → 412,19
/**
* 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
*
* @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)
{
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree)nouvelleDonnees ;
if(nouvelArbre.getRootNode().getChildNodes().length <= 0)
{
if (nouvelArbre.getRootNode().getChildNodes().length <= 0) {
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags") ;
root.setId("racine") ;
420,18 → 439,17
rootChild[i].remove() ;
}
getArbreMotsCles().getRootNode().appendChild(nouvelArbre.getRootNode()) ;
getArbreMotsCles().getRootNode().appendChild(
nouvelArbre.getRootNode());
// si l'arbre n'était pas encore considéré comme instancié
if(!estInstancie)
{
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)
{
if (motsCleInitialises == false && motsClesEnAttente != null) {
// on les coche
//cocherMotsCles(motsClesEnAttente) ;
motsCleInitialises = true ;
438,28 → 456,26
}
}
// Si on reçoit un tableau de String (cas ou l'on séléectionne une nouvelle image)
if(nouvelleDonnees instanceof String[])
{
// 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
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
{
// 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)
{
private String genererIdMotCle(TreeNode nd) {
return ""+(nd.hashCode()+(Math.random()*10000)) ;
}
 
/trunk/src/org/tela_botanica/client/vues/BarreNotationVue.java
12,6 → 12,7
/**
* Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique,
* utilisant Ajax (et pas CSS)
*
* @author aurelien
*
*/
43,18 → 44,19
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreNotationVue()
{
private BarreNotationVue() {
super() ;
}
/**
* Constructeur avec arguments
* @param im le médiateur à associer à la vue
* @param noteMax la note maximale
*
* @param im
* le médiateur à associer à la vue
* @param noteMax
* la note maximale
*/
public BarreNotationVue(ImageMediateur im, int noteMax)
{
public BarreNotationVue(ImageMediateur im, int noteMax) {
iMediateur = im ;
setNoteMax(noteMax) ;
this.setSize(200, 100) ;
66,22 → 68,20
}
public void 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'à
// 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++)
{
for (int i = 0; etoiles[i] != enCours; i++) {
etoiles[i].setUrl("note-hover.gif") ;
}
enCours.setUrl("note-hover.gif") ;
95,7 → 95,6
afficherNote() ;
}
 
}) ;
etoiles[i].addClickListener(new ClickListener() {
104,9 → 103,9
int i = 0 ;
// on récupère le numéro de l'étoile sur laquelle on a cliqué
while(etoiles[i] != (Image)sender)
{
// 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
114,7 → 113,6
}
}) ;
}
127,23 → 125,21
boolean repandreRaffraichissement) {
// si on recoit un tableau de string
if(nouvelleDonnees instanceof 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)
{
if (noteInt != -1 && noteInt >= 0) {
noter(noteInt) ;
}
// sinon si l'entier vaut -1
else
{
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)
// 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
156,10 → 152,11
/**
* Affecte une note à la barre et rafraichit l'affichage
* @param note la nouvelle note
*
* @param note
* la nouvelle note
*/
public void noter(int note)
{
public void noter(int note) {
// on affecte la note
noteEnCours = note ;
// on met le boolean de notation à true (l'image est notée)
170,10 → 167,11
/**
* Setteur pour la note maximale
* @param nMax la nouvelle note maximale
*
* @param nMax
* la nouvelle note maximale
*/
public void setNoteMax(int nMax)
{
public void setNoteMax(int nMax) {
// on affecte la note
noteMax = nMax ;
// on prépare le tableau d'image
180,8 → 178,7
etoiles = new Image[noteMax] ;
// qu'on remplit par defaut avec des images d'étoiles vides
for(int i = 0 ; i < noteMax ; i++)
{
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]) ;
191,41 → 188,35
/**
* Affiche la note d'une image sous la forme d'étoiles
*/
public void afficherNote()
{
public void afficherNote() {
// si l'image est notée
if(estNote)
{
if (estNote) {
// on affiche autant d'étoiles que le chiffre de la note
for(int i = 0 ; i <= noteEnCours ; i++)
{
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++)
{
// 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
{
else {
// on remplit toute la barre avec des étoiles vides
for(int i = 0 ; i < noteMax ; i++)
{
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()
{
public String getNote() {
return ""+noteEnCours ;
}
 
/trunk/src/org/tela_botanica/client/vues/MenuImageVue.java
10,6 → 10,7
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
30,20 → 31,35
private Item supprimerImage = null ;
 
/**
* Item pour l'ajout d'images à la selection
*/
private Item ajouterImageSelection = null;
 
/**
* Item pour vider la selection d'images
*/
private Item viderSelection = null;
 
/**
* Item pour lier la selection d'images
*/
private Item afficherSelection = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuImageVue()
{
private MenuImageVue() {
super();
}
/**
* Constructeur avec paramètre
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public MenuImageVue(ImageMediateur im)
{
public MenuImageVue(ImageMediateur im) {
super() ;
iMediateur = im ;
51,8 → 67,16
// on construit le menu
uploaderImage = new Item("Uploader des images") ;
supprimerImage = new Item("Supprimer les images selectionnées") ;
ajouterImageSelection = new Item(
"Ajouter les images sélectionnées au tampon");
viderSelection = new Item("Vider le tampon");
afficherSelection = new Item("Afficher le tampon");
addItem(uploaderImage);
addItem(supprimerImage) ;
addSeparator() ;
addItem(ajouterImageSelection);
addItem(viderSelection);
addItem(afficherSelection);
// on ajoute les listeners
ajouterListeners() ;
61,8 → 85,7
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners()
{
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
70,19 → 93,32
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'upload
if(item.equals(uploaderImage))
{
if (item.equals(uploaderImage)) {
// on notifie le médiateur
getIMediateur().uploaderImages() ;
}
// si c'est la suppression
if(item.equals(supprimerImage))
{
if (item.equals(supprimerImage)) {
// on notifie le médiateur
getIMediateur().supprimerImages() ;
}
// si c'est l'ajout à la sélection
if (item.equals(ajouterImageSelection)) {
getIMediateur().ajouterImagesSelection();
}
 
// si c'est le vidage de la sélection
if (item.equals(viderSelection)) {
getIMediateur().viderSelection();
}
 
// si c'est la liaison
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
 
// enfin, on cache le menu
hide() ;
93,10 → 129,10
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur()
{
public ImageMediateur getIMediateur() {
return iMediateur ;
}
 
/trunk/src/org/tela_botanica/client/vues/MiniListeObservationVue.java
17,70 → 17,70
import com.gwtext.client.core.EventObject;
import com.gwtext.client.dd.DragData;
 
/**
* Fausse liste d'observation pour tester le drag n' drop et l'insertion
* Est vouée à devenir une véritable liste avec de vraie données
* @author aurelien
*
*/
public class MiniListeObservationVue extends GridPanel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null ;
/**
* Booléen d'instanciation
*/
private boolean estInstancie = false ;
/**
* Le modèle de colonnes
*/
private ColumnModel colModel = null ;
/**
* Constructeur avec arguments
* @param im le médiateur à associer à la vue
*/
public MiniListeObservationVue(ImageMediateur im)
{
iMediateur = im ;
this.setId("x-view-mini-obs") ;
final Store store = new SimpleStore(new String[]{"plante"}, getObs());
// on crée un store simple contenant un petit set de données et deux colonnes
final Store store = new SimpleStore(new String[]{"id_obs","plante"}, getObs());
ColumnConfig[] columns = {
//new ColumnConfig("Numero", "num_obs", 45, true),
new ColumnConfig("Taxon", "plante", 45, true) } ;
new ColumnConfig("Numero", "id_obs", 65, true),
new ColumnConfig("Taxon", "plante", 150, true) } ;
ColumnModel columnModel = new ColumnModel(columns);
colModel = columnModel ;
setTitle("Observations");
// on associe le modèle de colonnes
setColumnModel(columnModel);
setHeight(390);
setWidth(200);
//Enable drag and drop
// on autorise le drag 'n drop pour un certain groupe
this.setEnableDragDrop(true);
//You need to set the same group for both grids
this.setDdGroup("DragGroupName");
store.load();
setStore(store) ;
// on configure le drag 'n drop
configDragAndDrop() ;
}
public void ajouterListeners()
/**
* Configure le drag 'n drop pour la liste
*/
private void configDragAndDrop()
{
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 (!estInstancie) {
//configDragAndDrop() ;
//estInstancie = true ;
}
}
 
public void onShow(Component component) {
 
}
 
});
}
public void configDragAndDrop()
{
// on choisit le texte qui sera affiché lors d'un drag 'n drop
setDragDropText("Faites glisser la selection d'observations sur une image pour les lier") ;
125,6 → 125,9
}
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
// TODO Auto-generated method stub
131,13 → 134,26
}
/**
* Renvoie le faux set de données pour le store
* @return un tableau à deux colonnes int - String
*/
private Object[][] getObs() {
return new Object[][]{
new Object[]{"Plante1"} ,
new Object[]{"Plante2"},
new Object[]{"Plante3"},
new Object[]{"Plante4"},
new Object[]{"Plante5"}
new Object[]{"1","Plantum bizarrum"},
new Object[]{"2","Feuillum etrangum"},
new Object[]{"3","Spirus cotapilis"},
new Object[]{"4","Birita raborum"},
new Object[]{"5","Spacea sinea"},
new Object[]{"6","Spacea subtea"},
new Object[]{"7","Buissnum petitum"},
new Object[]{"8","Acer monspessulanum"},
new Object[]{"9","Geranium prouticorum"},
new Object[]{"10","Rosae epania"},
new Object[]{"11","Rosea rougea"},
new Object[]{"12","Liciea rosa"},
new Object[]{"13","Liciea bella"}
} ;
}
 
/trunk/src/org/tela_botanica/client/vues/BarreRechercheFiltreVue.java
11,12 → 11,14
import com.gwtext.client.widgets.form.TextField;
 
/**
* Fenêtre de recherche pour les mots clés, contenant un champ texte,
* et un bouton cliquable
* 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 {
public class BarreRechercheFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Médiateur associé à la vue
43,17 → 45,16
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreRechercheFiltreVue()
{
private BarreRechercheFiltreVue() {
super() ;
}
/**
* Constructeur avec médiateur
*
* @param im
*/
public BarreRechercheFiltreVue(ImageMediateur im)
{
public BarreRechercheFiltreVue(ImageMediateur im) {
super() ;
iMediateur = im ;
74,8 → 75,7
/**
* ajoute des listeners
*/
private void ajouterListeners()
{
private void ajouterListeners() {
// gestion de la touche entrée
champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() {
83,10 → 83,10
public void onKey(int key, EventObject e) {
valider() ;
getIMediateur().obtenirPhotoGalerie(getIMediateur().getFiltreCommentaires()) ;
getIMediateur().obtenirPhotoGalerie(
getIMediateur().getFiltreCommentaires());
}
}) ;
}
102,6 → 102,7
 
/**
* renvoie l'état du filtre (modifié ou non)
*
* @return l'état du filtre
*/
public boolean renvoyerEtatFiltre() {
111,6 → 112,7
 
/**
* Renvoie le nom du filtre
*
* @return le nom du filtre
*/
public String renvoyerNomFiltre() {
120,10 → 122,12
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
public String[] renvoyerValeursAFiltrer() {
valider() ;
String[] valeurFiltre = {"ci_meta_comment" , motsAChercher } ;
return valeurFiltre ;
}
130,19 → 134,18
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur()
{
public ImageMediateur getIMediateur() {
return iMediateur ;
}
/**
* Effectue quelque opérations dans la classe et envoie une requête de données
* au médiateur
* Effectue quelque opérations dans la classe et envoie une requête de
* données au médiateur
*/
public void valider()
{
public void valider() {
filtreModifie = true ;
motsAChercher = champRecherche.getText() ;
}
/trunk/src/org/tela_botanica/client/vues/MenuFiltreVue.java
29,17 → 29,17
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuFiltreVue()
{
private MenuFiltreVue() {
super();
}
/**
* Constructeur avec paramètre
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public MenuFiltreVue(ImageMediateur im)
{
public MenuFiltreVue(ImageMediateur im) {
super() ;
iMediateur = im ;
57,8 → 57,7
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners()
{
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
66,15 → 65,13
public void onItemClick(BaseItem item, EventObject e) {
// si c'est la recherche par mots clé
if(item.equals(chercherImage))
{
if (item.equals(chercherImage)) {
// on notifie le médiateur
// getIMediateur().afficherFiltreMotsCles() ;
}
// si c'est la recherche par commentaires
if(item.equals(chercherCommentaire))
{
if (item.equals(chercherCommentaire)) {
// on notifie le médiateur
//getIMediateur().afficherFiltreCommentaires() ;
}
89,10 → 86,10
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur()
{
public ImageMediateur getIMediateur() {
return iMediateur ;
}
/trunk/src/org/tela_botanica/client/vues/PanneauMetadonneesVue.java
20,7 → 20,9
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
* Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il
* implémente l'interface rafraichissable
*
* @author aurelien
*
*/
73,7 → 75,12
* Le champ date
*/
private DateField dateImage = null ;
/**
* La mini liste des observations
*/
private MiniListeObservationVue miniListeObservation = null ;
/**
* Le bouton de validation
*/
Button validerInfo = null ;
92,17 → 99,16
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private PanneauMetadonneesVue()
{
private PanneauMetadonneesVue() {
super() ;
}
/**
* Constructeur avec argument
*
* @param im
*/
public PanneauMetadonneesVue(ImageMediateur im)
{
public PanneauMetadonneesVue(ImageMediateur im) {
super() ;
// on associe le médiateur
115,7 → 121,6
panneauMotsCles = new ArbreMotsClesVue(im) ;
panneauMotsCles.setHeight("500px") ;
Panel sousPanneauInfosGenerales = new Panel("Infos Générales") ;
sousPanneauInfosGenerales.setLayout(new VerticalLayout());
sousPanneauInfosGenerales.setBorder(false) ;
144,6 → 149,8
noteVue = new BarreNotationVue(im, 5) ;
miniListeObservation = new MiniListeObservationVue(im) ;
 
sousPanneauInfosGenerales.add(labelComm) ;
sousPanneauInfosGenerales.add(commentaireGeneral) ;
sousPanneauInfosGenerales.add(labelDate) ;
157,14 → 164,13
panneauInfoGrid.setBorder(false);
panneauInfoGrid.setAutoHeight(true);
panneauInfoGrid.add(sousPanneauInfosGenerales) ;
panneauInfoGrid.add(panneauMotsCles) ;
this.add(panneauInfoGrid) ;
this.add(panneauExifGrid) ;
this.add(panneauIptcGrid) ;
this.add(miniListeObservation) ;
gViewExif = new GridView();
gViewExif.setForceFit(true);
189,7 → 195,6
IptcGrid.setAutoHeight(true);
IptcGrid.setSorted(false);
panneauExifGrid.add(ExifGrid);
panneauIptcGrid.add(IptcGrid);
196,14 → 201,12
// on ajoute les listeners
ajouterListeners() ;
// on effectue le rendu
this.doLayout(true) ;
}
private void ajouterListeners()
{
private void ajouterListeners() {
// on ajoute un écouteur
validerInfo.addListener(new ButtonListenerAdapter() {
 
212,8 → 215,10
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()) ;
// lors du clic sur le bouton valider on met à jour les
// commentaires et la date
getIMediateur().mettreAJourInfo(commentaireGeneral.getText(),
dateImage.getRawValue(), noteVue.getNote());
}
});
273,8 → 278,7
/**
* Desactive visuellement ce panneau
*/
public void desactiverPanneau()
{
public void desactiverPanneau() {
this.setDisabled(true) ;
}
281,30 → 285,32
/**
* Active visuellement ce panneau
*/
public void activerPanneau()
{
public void activerPanneau() {
this.setDisabled(false) ;
}
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur()
{
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
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen de notification de mise à jour
*/
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
// si on reçoit un tableau d'objets
if(nouvelleDonnees instanceof Object[])
{
if (nouvelleDonnees instanceof Object[]) {
// extrait infos, exifs et iptc
Object meta[] = (Object[])nouvelleDonnees ;
String[][] exif = (String[][])meta[0] ;
314,26 → 320,19
NameValuePair[] exifSource = new NameValuePair[exif.length] ;
NameValuePair[] iptcSource = new NameValuePair[iptc.length] ;
int maxLength ;
if(exif.length <= iptc.length)
{
if (exif.length <= iptc.length) {
maxLength = iptc.length ;
}
else
{
} else {
maxLength = exif.length ;
}
for(int i = 0; i < maxLength ; i++)
{
if(i < exif.length && !exif[i][0].equals("null"))
{
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"))
{
if (i < iptc.length && !iptc[i][0].equals("null")) {
iptcSource[i] = new NameValuePair(iptc[i][0],iptc[i][1]) ;
}
}
351,6 → 350,7
 
/**
* Accesseur pour le panneau des mots clés
*
* @return the panneauMotsCles
*/
public ArbreMotsClesVue getPanneauMotsCles() {
360,4 → 360,9
public BarreNotationVue getNoteVue() {
return noteVue ;
}
public MiniListeObservationVue getMiniListeObservation()
{
return miniListeObservation ;
}
}
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
17,10 → 17,12
/**
* 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 {
public class ArbreMotsClesFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
50,17 → 52,17
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreMotsClesFiltreVue()
{
private ArbreMotsClesFiltreVue() {
super() ;
}
/**
* Constructeur avec paramètres
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesFiltreVue(ImageMediateur im)
{
public ArbreMotsClesFiltreVue(ImageMediateur im) {
// on crée le panel
super() ;
87,11 → 89,11
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel()
{
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour accélérer l'affichage
// 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) {
112,7 → 114,6
arbreMotsCles.setRootVisible(true) ;
arbreMotsCles.setBorder(false) ;
// on met en forme le layout
((Panel)component).add(arbreMotsCles) ;
120,7 → 121,10
ajouterListeners() ;
// et on demande l'arbre des mots clés
getIMediateur().obtenirArbreMotsCles(getIMediateur().getPanneauFiltres().getMotsClesFiltre()) ;
getIMediateur()
.obtenirArbreMotsCles(
getIMediateur().getPanneauFiltres()
.getMotsClesFiltre());
// enfin on considère le composant comme instancié
estInstancie = true ;
133,8 → 137,7
/**
* ajoute les listeners pour les boutons et le cochage des mots clés
*/
private void ajouterListeners()
{
private void ajouterListeners() {
 
}
145,8 → 148,7
boolean repandreRaffraichissement) {
// si on a reçu un arbre
if(nouvelleDonnees instanceof Tree)
{
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree)nouvelleDonnees ;
// on vide tous les noeuds
158,15 → 160,14
return true ;
}
}) ;
// et on recopie le nouvel arbre
copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles.getRootNode()) ;
copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
.getRootNode());
// si l'arbre n'était pas encore considéré comme instancié
if(!estInstancie)
{
if (!estInstancie) {
// on signale que oui
estInstancie = true ;
}
177,20 → 178,18
show() ;
}
if(nouvelleDonnees instanceof TreeNode)
{
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)
{
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
{
else {
// alors on supprime d'abord le noeud concerné
arbreMotsCles.getTree().getNodeById(nd.getId()+"_filtre").remove() ;
arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre")
.remove();
}
// on cherche le père du nouveau noeud
209,12 → 208,10
}
// si on reçoit une string
if(nouvelleDonnees instanceof 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)
{
if (arbreMotsCles.getTree().getNodeById(idSupp) != null) {
// on le supprime
arbreMotsCles.getTree().getNodeById(idSupp).remove() ;
}
224,25 → 221,24
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur()
{
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()
{
public TreePanel getArbreMotsCles() {
return arbreMotsCles ;
}
/**
* Méthode héritée de Filtrable
* renvoie le nom du filtre
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
public String renvoyerNomFiltre() {
251,6 → 247,7
/**
* 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() {
263,15 → 260,16
}
/**
* 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
* 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)
{
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes() ;
for (int i = 0; i < ndNodeFils.length; i++) {
283,8 → 281,7
child.setUserObject(usObj) ;
ndPereCopie.appendChild(child) ;
if(! ndNodeFils[i].isLeaf())
{
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i],child) ;
}
293,8 → 290,7
}
 
/**
* Méthode héritée de Filtrable
* Renvoie l'état du filtre (modifié ou non)
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
public boolean renvoyerEtatFiltre() {
301,27 → 297,29
return filtreModifie ;
}
public void valider()
{
if(estInstancie)
{
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() {
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()) ;
// 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]) ;
getIMediateur().mettreAjourMotsClesId(usObject[0],
usObject[1]);
if(tn.getUI().isChecked())
{
// et les concatène à la string des mots clés en cours
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots clés en
// cours
motsClesEncours += usObject[1]+"," ;
}
/trunk/src/org/tela_botanica/client/vues/GalerieImageVue.java
5,7 → 5,6
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;
14,6 → 13,10
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.util.Format;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.DataView;
20,13 → 23,15
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.DataViewListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
 
/**
* Galerie d'images miniatures
* Avec barre de pagination
* Galerie d'images miniatures Avec barre de pagination
*
* @author aurelien
*/
public class GalerieImageVue extends Panel implements Rafraichissable, VueListable {
public class GalerieImageVue extends Panel implements Rafraichissable,
VueListable {
 
/**
* instance du médiateur
33,15 → 38,18
*/
private ImageMediateur iMediateur = null;
/**
* Dataview, littéralement "vue de données" qui permet de définir la manière d'afficher les données
* 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
* 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
* Barre de pagination gérant l'affichage d'un nombre donné d'élements par
* page et la navigation entre eux
*/
private pageToolBarVue pt = null ;
/**
53,14 → 61,15
* Constructeur sans argument, privé car ne doit pas être utilisé
*/
@SuppressWarnings("unused")
private GalerieImageVue()
{
private GalerieImageVue() {
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur avec lequel la vue va communiquer
*
* @param im
* le médiateur avec lequel la vue va communiquer
*/
public GalerieImageVue(ImageMediateur im) {
super("Galerie");
69,7 → 78,8
// 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)
// 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) {
 
87,7 → 97,8
}
 
/**
* Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la vue de données
* Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la
* vue de données
*/
public void ajouterListenersDataView() {
 
138,7 → 149,8
} else {
// sinon on notifie le médiateur
getIMediateur().selection();
// et on lui demande de synchroniser la séléction avec les autres vues
// et on lui demande de synchroniser la séléction avec les
// autres vues
getIMediateur().synchroniserSelection("galerie");
}
}
148,6 → 160,7
 
/**
* Accesseur pour la dataview
*
* @return la dataview
*/
public DataView getDView() {
156,7 → 169,9
 
/**
* Renvoie les ids des images sélectionnées
* @return un tableau de String contenant les identifiants 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();
173,6 → 188,7
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
181,6 → 197,7
 
/**
* Accesseur pour le store
*
* @return le store associé à la vue
*/
public Store getSt() {
189,15 → 206,16
/**
* Accesseur pour la toolbar
*
* @return la toolbar associée à la vue
*/
public pageToolBarVue getToolBarVue()
{
public pageToolBarVue getToolBarVue() {
return pt ;
}
 
/**
* Fonction d'initialisation du contenu (appelée lors du premier affichage de la liste)
* Fonction d'initialisation du contenu (appelée lors du premier affichage
* de la liste)
*/
public void initialiser() {
211,7 → 229,8
"<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
// pour des raisons de performances on compile le template en une
// fonction
template.compile();
 
// la dataview affichera les images en accord avec le template
218,11 → 237,11
// 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);
 
247,11 → 266,11
st = new Store(rd);
dView.setStore(st);
 
this.getDView().setLoadingText("chargement");
 
// ajouts de la gestion des evenements pour la dataview
ajouterListenersDataView();
configDragAndDrop() ;
 
this.add(dView);
261,6 → 280,35
estInstancie = true ;
}
 
public void configDragAndDrop()
{
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si les données proviennent d'une grille
if(data instanceof GridDragData)
{
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
return false ;
}
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
282,14 → 330,14
 
// 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
// 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)
{
if (!estInstancie) {
// alors le composant est considéré comme instancié
estInstancie = true ;
}
296,9 → 344,11
}
 
/**
* 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
* 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) {
 
/trunk/src/org/tela_botanica/client/vues/MenuIdVue.java
20,22 → 20,21
*/
private Item changerId = null ;
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuIdVue()
{
private MenuIdVue() {
super();
}
/**
* Constructeur avec paramètre
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public MenuIdVue(ImageMediateur im)
{
public MenuIdVue(ImageMediateur im) {
super() ;
iMediateur = im ;
51,8 → 50,7
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners()
{
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
60,8 → 58,7
public void onItemClick(BaseItem item, EventObject e) {
// si c'est la recherche par commentaires
if(item.equals(changerId))
{
if (item.equals(changerId)) {
// on notifie le médiateur
getIMediateur().afficherMenuId() ;
}
76,10 → 73,10
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur()
{
public ImageMediateur getIMediateur() {
return iMediateur ;
}
 
/trunk/src/org/tela_botanica/client/vues/ListeImageVue.java
11,11 → 11,16
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.RowSelectionModel;
87,14 → 92,15
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
private ListeImageVue()
{
private ListeImageVue() {
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public ListeImageVue(ImageMediateur im) {
 
109,56 → 115,65
setBottomToolbar(bt) ;
 
// on construit le modèle de colonnes
numImage = new ColumnConfig("numéro", "num_image", 30, true, new Renderer() {
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) {
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>";
return "<div class=\"centered-list\">" + ImgNum
+ "</div>";
}
}) ;
datImage = new ColumnConfig("date", "dat_image", 120, true, new Renderer() {
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) {
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
String ImgDat = record.getAsString("dat_image");
if(ImgDat == null)
{
if (ImgDat == null) {
ImgDat = " " ;
}
return "<div class=\"centered-list\">"+ ImgDat +"</div>";
return "<div class=\"centered-list\">" + ImgDat
+ "</div>";
}
}) ;
lieImage = new ColumnConfig("lieu", "lie_image", 120, true, new Renderer() {
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) {
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
String ImgLie = record.getAsString("lie_image");
if(ImgLie == null)
{
if (ImgLie == null) {
ImgLie = " " ;
}
return "<div class=\"centered-list\">"+ ImgLie +"</div>";
return "<div class=\"centered-list\">" + ImgLie
+ "</div>";
}
}) ;
appImage = new ColumnConfig("appareil", "app_image", 120, true, new Renderer() {
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) {
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
String ImgApp = record.getAsString("app_image");
if(ImgApp == null)
{
if (ImgApp == null) {
ImgApp = " " ;
}
return "<div class=\"centered-list\">"+ ImgApp +"</div>";
return "<div class=\"centered-list\">" + ImgApp
+ "</div>";
}
}) ;
169,29 → 184,28
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
// 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>";
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) {
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)
{
if (noteImg >= 0) {
htmlImage += "<div class=\"img-note centered-list\">" ;
for(int i = 0 ; i <= noteImg ; i++)
{
for (int i = 0; i <= noteImg; i++) {
htmlImage += "<img src=\"note-on.gif\">" ;
}
htmlImage += "</div>" ;
204,7 → 218,8
}) ;
// on associe le modèle de colonnes
ColumnConfig[] cm = {numImage, urlImage, datImage, lieImage, appImage, noteImage};
ColumnConfig[] cm = { numImage, urlImage, datImage, lieImage, appImage,
noteImage };
modeleColonnes = new ColumnModel(cm);
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
221,7 → 236,8
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new StringFieldDef("note_image");
FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage, defNoteImage };
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage };
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
231,11 → 247,17
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("chargement");
//Enable drag and drop
this.setEnableDragDrop(true);
//You need to set the same group for both grids
this.setDdGroup("DragGroupName");
 
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
242,22 → 264,22
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é
// lors du premier rendu on demande les données qui sont déjà
// contenues dans la galerie qui est le premier élément affiché
public void onRender(Component component) {
 
if (!isEstInstancie()) {
setEstInstancie(true);
setDragDropText("Glissez les images sur la liste d'observation pour les lier") ;
getIMediateur().synchroniserSelection("galerie");
}
}
 
public void onShow(Component component) {
 
}
276,7 → 298,8
// 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
// 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);
298,21 → 321,62
 
// 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)
// 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
// et on lui demande de synchroniser la selection avec les
// autres vues
getIMediateur().synchroniserSelection("liste");
}
}
});
//Enable drag and drop
this.setEnableDragDrop(true);
 
//Same name in destination
this.setDdGroup("DragGroupName");
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//Now this is the important part, you need a drop target
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
if(data instanceof GridDragData)
{
GridDragData gdd = (GridDragData)data ;
if(gdd.getGrid().getId().equals("listeImageGrid"))
{
return false ;
}
else
{
return iMediateur.lierObsDD(source, e, data, getId()) ;
}
}
else
{
return false ;
}
 
}
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Méthode héritée de l'interface VueListable
* Sélectionne les images dans la galerie suivant les identifiants donnés en paramètres
* 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();
329,6 → 393,7
 
/**
* Accesseur pour la config de colonnes
*
* @return la config de colonnes
*/
public ColumnConfig getCl() {
337,6 → 402,7
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
345,6 → 411,7
 
/**
* Accesseur pour le modèle de colonnes
*
* @return le modèle de colonnes
*/
public ColumnModel getModeleColonnes() {
353,6 → 420,7
 
/**
* Accesseur pour le store
*
* @return le store contenant les données
*/
public Store getSt() {
361,6 → 429,7
/**
* Accesseur pour le booleen d'instanciation
*
* @return le booleen d'instanciation
*/
public boolean isEstInstancie() {
369,8 → 438,11
 
/**
* Méthode héritée de l'interface rafraichissable
* @param nouvelleDonnees les nouvelles données
* @param repandreRafraichissement le booleen de notification du rafraichissement
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen de notification du rafraichissement
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
396,7 → 468,9
 
/**
* Sélectionne des enregistrements donné
* @param sel un tableau d'enregistrement à selectionner
*
* @param sel
* un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
408,16 → 482,18
/**
* Accesseur pour la toolbar de pagination
*
* @return la toolbar de pagination
*/
public pageToolBarVue getToolBarVue()
{
public pageToolBarVue getToolBarVue() {
return bt ;
}
 
/**
* Setteur pour le booleen d'instanciation
* @param estInstancie la nouvelle valeur du booleen
*
* @param estInstancie
* la nouvelle valeur du booleen
*/
public void setEstInstancie(boolean estInstancie) {
this.estInstancie = estInstancie;
/trunk/src/org/tela_botanica/client/vues/DateFiltreVue.java
1,6 → 1,5
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;
10,8 → 9,9
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
* 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
*
*/
36,17 → 36,17
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private DateFiltreVue()
{
private DateFiltreVue() {
super() ;
}
/**
* Constructeur avec arguments
* @param im le médiateur à associer
*
* @param im
* le médiateur à associer
*/
public DateFiltreVue(ImageMediateur im)
{
public DateFiltreVue(ImageMediateur im) {
super() ;
setPaddings(5) ;
setCollapsible(true) ;
68,8 → 68,7
/**
* Ajoute les listeners
*/
public void ajouterListeners()
{
public void ajouterListeners() {
}
94,6 → 93,7
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
@SuppressWarnings("unused")
124,21 → 124,22
public String[] renvoyerValeursAFiltrer() {
// si la date est valide
if(filtreDate.isValid())
{
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] ;
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)
// 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/ZoomImageVue.java
1,6 → 1,5
package org.tela_botanica.client.vues;
 
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
9,15 → 8,22
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
 
/**
* Panneau d'affichage d'une image avec des boutons précdents et suivant
*
* @author aurelien
*
*/
56,6 → 62,11
private int imageWidth = 0 ;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
 
/**
* Booleen d'initalisation général
*/
private boolean initialise = false ;
69,17 → 80,17
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private ZoomImageVue()
{
private ZoomImageVue() {
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur à associer à la vue
*
* @param im
* le médiateur à associer à la vue
*/
public ZoomImageVue(ImageMediateur im)
{
public ZoomImageVue(ImageMediateur im) {
super("Zoom");
setId("x-view-zoom-panel") ;
// on associe le médiateur
88,7 → 99,6
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() {
105,24 → 115,21
if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
 
// on simule un clic sur le bouton précédent
if(event.getMouseWheelVelocityY() >= 1)
{
if (event.getMouseWheelVelocityY() >= 1) {
prev.click() ;
}
// ou suivant
if(event.getMouseWheelVelocityY() <= -1)
{
if (event.getMouseWheelVelocityY() <= -1) {
suiv.click() ;
}
}
}
};
this.setHeader(false) ;
imageConteneur = new Panel() ;
imageConteneur.setBorder(false);
129,7 → 136,8
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
// 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) ;
152,6 → 160,8
conteneurInitialise = true ;
initialise = true ;
configDragAndDrop() ;
 
// on ajoute les listeners
ajouterListeners();
 
159,31 → 169,32
 
/**
* 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
*
* @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) {
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
// si on reçoit une string
if(nouvelleDonnees instanceof String[] && initialise && conteneurInitialise)
{
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise) {
String[] infos = (String[])nouvelleDonnees ;
// c'est l'url de l'image qu'on associe à la vue
if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
getImage().setUrl(infos[0]);
if(infos[1] != null && infos[2] != null)
{
int x = Integer.parseInt(infos[1]) ;
int y = Integer.parseInt(infos[2]) ;
setTailleImage(x,y) ;
setIdImage(infos[3]) ;
 
verifierEtRetaillerImage() ;
}
}
else
{
} else {
// sinon on met une image vide
getImage().setUrl("vide.jpeg") ;
}
192,8 → 203,7
/**
* Desactive visuellement le panneau et les boutons
*/
public void desactiverPanneau()
{
public void desactiverPanneau() {
getImage().setUrl("vide.jpeg") ;
prev.setEnabled(false) ;
suiv.setEnabled(false);
202,8 → 212,7
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau()
{
public void activerPanneau() {
prev.setEnabled(true);
suiv.setEnabled(true);
}
211,8 → 220,7
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners()
{
public void ajouterListeners() {
// gestion du clic sur le bouton précedent
prev.addClickListener(new ClickListener() {
241,8 → 249,8
// lors d'un redimensionnement de l'application
public void onBodyResize(Panel panel,java.lang.String width,java.lang.String height)
{
public void onBodyResize(Panel panel, java.lang.String width,
java.lang.String height) {
// on vérifie et on retaille l'image
verifierEtRetaillerImage() ;
}
253,8 → 261,7
// avant de finir d'afficher
public void onAfterLayout(Container self)
{
public void onAfterLayout(Container self) {
// on redimensionne
verifierEtRetaillerImage() ;
}
263,13 → 270,12
}
 
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas echeant
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage()
{
public void verifierEtRetaillerImage() {
// si l'image est nulle
if(image == null)
{
if (image == null) {
// on ne fait rien
return ;
}
278,7 → 284,8
int originalX = getTailleImage()[0] ;
int originalY = getTailleImage()[1] ;
// on la transforme en float (la division entre entier donne de curieux résultats)
// 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() ;
294,39 → 301,73
int tailleConteneurY = imageConteneur.getHeight() ;
// si celle-ci est égale à 0 (conteneur mal initialisé)
/*if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0)
/*
* if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
* essaie de la calculer en fonction de la taille du parent et des
* frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
* this.getWidth() - prev.getOffsetWidth() * 2 ;
* }
*/
 
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
// si la longueur de l'image est la plus grande des deux
if (originalX > originalY) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = tailleConteneurX;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
} else {
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = tailleConteneurY;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
getImage().setSize("" + nouvelleTailleX + "px",
"" + nouvelleTailleY + "px");
}
public void configDragAndDrop()
{
// on essaie de la calculer en fonction de la taille du parent et des frères
tailleConteneurY = this.getHeight() ;
tailleConteneurX = this.getWidth() - prev.getOffsetWidth() * 2 ;
}*/
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop grande)
if(originalY > tailleConteneurY || originalX > tailleConteneurX)
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
// si la longueur de l'image est la plus grande des deux
if(originalX > originalY)
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si on reçoit des données provenant d'une grille
if(data instanceof GridDragData)
{
// on 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) ;
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
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) ;
return false ;
}
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
// 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() {
335,6 → 376,7
 
/**
* Accesseur au conteneur de l'image
*
* @return le conteneur de l'image
*/
public Image getImage() {
342,7 → 384,17
}
 
/**
* Acesseurs pour l'identifiant de l'image
* @return l'id de l'image
*/
public String getIdImage()
{
return idImage ;
}
 
/**
* Accesseur pour le bouton précédent
*
* @return le bouton précédent
*/
public com.google.gwt.user.client.ui.Button getPrev() {
351,6 → 403,7
 
/**
* Accesseur pour le bouton suivant
*
* @return le bouton suivant
*/
public com.google.gwt.user.client.ui.Button getSuiv() {
359,26 → 412,41
/**
* Setter pour la taille de l'image
* @param X la largeur en pixels
* @param Y la hauteur en pixels
*
* @param X
* la largeur en pixels
* @param Y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y)
{
public void setTailleImage(int x, int y) {
imageHeight = y ;
imageWidth = x ;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
idImage = id ;
}
 
/**
* renvoie la taille originale de l'image
*
* @return un tableau de deux entiers contenant la largeur puis la hauteur
*/
public int[] getTailleImage()
{
public int[] getTailleImage() {
int[] taille = {imageHeight,imageWidth} ;
return taille ;
}
 
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
return imageConteneur ;
/trunk/src/org/tela_botanica/client/vues/BarreOutilsVue.java
5,10 → 5,10
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
* 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
*
*/
46,14 → 46,15
* Constructeur sans argument (ne doit pas être utilisé donc privé)
*/
@SuppressWarnings("unused")
private BarreOutilsVue()
{
private BarreOutilsVue() {
super() ;
}
/**
* Constructeur avec paramètres
* @param im le médiateur à associer à la vue
*
* @param im
* le médiateur à associer à la vue
*/
public BarreOutilsVue(ImageMediateur im) {
71,8 → 72,6
this.addButton(utilisateur) ;
}
 
 
/**
* @return the images
*/
80,7 → 79,6
return images;
}
 
 
/**
* @return the iMediateur
*/
/trunk/src/org/tela_botanica/client/vues/SelectionFiltreVue.java
New file
0,0 → 1,89
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.form.Checkbox;
 
public class SelectionFiltreVue extends Panel implements Filtrable {
 
private ImageMediateur iMediateur = null;
 
private boolean filtreModifie = false;
 
private Checkbox check = null;
@SuppressWarnings("unused")
private SelectionFiltreVue()
{
super() ;
}
 
public SelectionFiltreVue(ImageMediateur im) {
 
super();
iMediateur = im ;
Label labelRecherche = new Label(
"Afficher uniquement les images dans le tampon :");
add(labelRecherche);
setBorder(false);
setPaddings(5);
 
/*
* combo = new ComboBox() ; String tout = "toutes les images "; String
* selection = "dans le tampon seulement" ; Object[][] data = new
* Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ;
* data[1][1] = selection ;
* // creation du store qui les contient FieldDef defIdChoix = new
* IntegerFieldDef("id_choix"); FieldDef defNomChoix = new
* StringFieldDef("nom_choix");
*
* FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new
* RecordDef(defTab) ;
*
* final MemoryProxy dataProxy = new MemoryProxy(data); final
* ArrayReader reader = new ArrayReader(rd);
*
* st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ;
* combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL);
* combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ;
* add(combo) ;
*/
 
check = new Checkbox();
check.setChecked(false) ;
add(check);
 
}
 
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
public String renvoyerNomFiltre() {
 
return "Filtre par tampon";
}
 
public String[] renvoyerValeursAFiltrer() {
 
if (check.getValue()) {
String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() };
return val;
}
String[] val = { "ci_id_tampon", "" };
return val;
}
 
public void valider() {
 
filtreModifie = true;
 
}
 
}