2 |
aperonnet |
1 |
package org.tela_botanica.client.image;
|
|
|
2 |
|
|
|
3 |
import java.util.HashMap;
|
|
|
4 |
import java.util.Iterator;
|
|
|
5 |
|
|
|
6 |
import org.tela_botanica.client.interfaces.Rafraichissable;
|
|
|
7 |
import org.tela_botanica.client.modeles.Configuration;
|
|
|
8 |
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
|
|
|
9 |
import org.tela_botanica.client.modeles.ImageCarnet;
|
|
|
10 |
import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;
|
|
|
11 |
import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
|
|
|
12 |
import org.tela_botanica.client.modeles.ListeImageCarnet;
|
|
|
13 |
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
|
|
|
14 |
import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;
|
|
|
15 |
|
|
|
16 |
import com.google.gwt.json.client.JSONArray;
|
|
|
17 |
import com.google.gwt.json.client.JSONObject;
|
|
|
18 |
import com.gwtext.client.data.ArrayReader;
|
|
|
19 |
import com.gwtext.client.data.FieldDef;
|
|
|
20 |
import com.gwtext.client.data.IntegerFieldDef;
|
|
|
21 |
import com.gwtext.client.data.MemoryProxy;
|
|
|
22 |
import com.gwtext.client.data.Node;
|
|
|
23 |
import com.gwtext.client.data.RecordDef;
|
|
|
24 |
import com.gwtext.client.data.Store;
|
|
|
25 |
import com.gwtext.client.data.StringFieldDef;
|
|
|
26 |
import com.gwtext.client.data.Tree;
|
|
|
27 |
import com.gwtext.client.widgets.tree.TreeNode;
|
|
|
28 |
|
|
|
29 |
/**
|
|
|
30 |
* Modèle d'accès aux données pour les images.
|
|
|
31 |
* C'est un singleton
|
|
|
32 |
* @author aurelien
|
|
|
33 |
*
|
|
|
34 |
*/
|
|
|
35 |
public class ImageModele implements Rafraichissable {
|
|
|
36 |
|
|
|
37 |
/**
|
|
|
38 |
* Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
|
|
|
39 |
*/
|
|
|
40 |
private static boolean estInstancie = false ;
|
|
|
41 |
|
|
|
42 |
/**
|
|
|
43 |
* le modèle lui même
|
|
|
44 |
*/
|
|
|
45 |
private static ImageModele thisModele = null ;
|
|
|
46 |
|
|
|
47 |
/**
|
|
|
48 |
* Le médiateur associé au modèle
|
|
|
49 |
*/
|
|
|
50 |
private ImageMediateur iMediateur = null ;
|
|
|
51 |
|
|
|
52 |
/**
|
|
|
53 |
* La configuration en cours
|
|
|
54 |
*/
|
|
|
55 |
private Configuration config = null ;
|
|
|
56 |
|
|
|
57 |
/**
|
|
|
58 |
* La liste des image affichées en cours
|
|
|
59 |
*/
|
|
|
60 |
private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;
|
|
|
61 |
/**
|
|
|
62 |
* Table de correspondance entre les mots clés et leurs identifiants
|
|
|
63 |
*/
|
|
|
64 |
private HashMap<String, String> motsCles = new HashMap<String, String>(0) ;
|
|
|
65 |
/**
|
|
|
66 |
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
|
|
|
67 |
*/
|
|
|
68 |
private Store st = null ;
|
|
|
69 |
/**
|
|
|
70 |
* Arbre des mots clés
|
|
|
71 |
*/
|
|
|
72 |
private com.gwtext.client.data.Tree arbreMotsCles = new Tree() ;
|
|
|
73 |
|
|
|
74 |
/**
|
|
|
75 |
* Numéro de page en cours
|
|
|
76 |
*/
|
|
|
77 |
private int pageEncours = 0 ;
|
|
|
78 |
/**
|
|
|
79 |
* Nombre de pages totales
|
|
|
80 |
*/
|
|
|
81 |
private int pageMax = 1 ;
|
|
|
82 |
/**
|
|
|
83 |
* Taille de page (par défaut 50)
|
|
|
84 |
*/
|
|
|
85 |
private int taillePage = 50 ;
|
|
|
86 |
/**
|
|
|
87 |
* Nombre d'éléments total correspondant à la requete
|
|
|
88 |
*/
|
|
|
89 |
private int nbElements = 0 ;
|
|
|
90 |
|
|
|
91 |
/**
|
|
|
92 |
* Retourne une instance de manière unique
|
|
|
93 |
* @param im le médiateur à associer
|
|
|
94 |
* @return l'instance du modèle
|
|
|
95 |
*/
|
|
|
96 |
static ImageModele Instance(ImageMediateur im)
|
|
|
97 |
{
|
|
|
98 |
// si le modèle n'est pas encore instancié
|
|
|
99 |
if(!estInstancie)
|
|
|
100 |
{
|
|
|
101 |
// on en crée un nouveau
|
|
|
102 |
estInstancie = true ;
|
|
|
103 |
thisModele = new ImageModele(im);
|
|
|
104 |
}
|
|
|
105 |
|
|
|
106 |
// sinon on retourne le "pointeur" vers le modèle lui-même
|
|
|
107 |
return thisModele ;
|
|
|
108 |
|
|
|
109 |
}
|
|
|
110 |
|
|
|
111 |
/**
|
|
|
112 |
* Le constructeur est privé et seule la méthode instance y accède
|
|
|
113 |
* @param im le médiateur à associer
|
|
|
114 |
*/
|
|
|
115 |
private ImageModele(ImageMediateur im) {
|
|
|
116 |
|
|
|
117 |
iMediateur = im ;
|
|
|
118 |
config = new Configuration() ;
|
|
|
119 |
}
|
|
|
120 |
|
|
|
121 |
/**
|
|
|
122 |
* Accesseur pour le médiateur
|
|
|
123 |
* @return le médiateur associé
|
|
|
124 |
*/
|
|
|
125 |
public ImageMediateur getIMediateur()
|
|
|
126 |
{
|
|
|
127 |
return iMediateur ;
|
|
|
128 |
}
|
|
|
129 |
|
|
|
130 |
/**
|
|
|
131 |
* Appelle le DAO asynchrone pour obtenir la liste des images
|
|
|
132 |
* @param r le rafraichissable auxquel on enverra les données
|
|
|
133 |
*/
|
|
|
134 |
public void obtenirPhotoGalerie(Rafraichissable r)
|
|
|
135 |
{
|
|
|
136 |
|
|
|
137 |
String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;
|
|
|
138 |
|
|
|
139 |
int tailleFiltres = motsClesFiltres.length ;
|
|
|
140 |
|
|
|
141 |
String[][] criteres = new String[tailleFiltres+1][2] ;
|
|
|
142 |
String[][] criteres2 = new String[tailleFiltres+2][2] ;
|
|
|
143 |
|
|
|
144 |
String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ;
|
|
|
145 |
criteres[0] = utilisateur ;
|
|
|
146 |
|
|
|
147 |
String[] limite = {"ci_limite" ,""+taillePage } ;
|
|
|
148 |
String[] taillePage = {"ci_numero_page",""+pageEncours} ;
|
|
|
149 |
|
|
|
150 |
criteres2[0] = limite ;
|
|
|
151 |
criteres2[1] = taillePage ;
|
|
|
152 |
|
|
|
153 |
for (int i = 0 ; i < motsClesFiltres.length; i++) {
|
|
|
154 |
|
|
|
155 |
criteres[i+1] = motsClesFiltres[i] ;
|
|
|
156 |
criteres2[i+2] = motsClesFiltres[i] ;
|
|
|
157 |
}
|
|
|
158 |
|
|
|
159 |
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
|
|
|
160 |
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this) ;
|
|
|
161 |
niaDAO.obtenirNombreImages(this, criteres) ;
|
|
|
162 |
|
|
|
163 |
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
|
|
|
164 |
ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
|
|
|
165 |
liaDAO.ObtenirListeImages(this, criteres2);
|
|
|
166 |
}
|
|
|
167 |
|
|
|
168 |
/**
|
|
|
169 |
* Appelle le DAO d'upload qui va choisir la methode d'upload adaptée
|
|
|
170 |
* et lancer l'interface appropriée
|
|
|
171 |
*/
|
|
|
172 |
@SuppressWarnings("static-access")
|
|
|
173 |
public void uploaderImages()
|
|
|
174 |
{
|
|
|
175 |
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this) ;
|
|
|
176 |
IuADaO.choisirMethodeUpload() ;
|
|
|
177 |
}
|
|
|
178 |
|
|
|
179 |
/**
|
|
|
180 |
* Met à jour la liste des images à partir d'un objet
|
|
|
181 |
* @param o la nouvelle liste d'image
|
|
|
182 |
*/
|
|
|
183 |
public void rafraichirListeImage(Object o)
|
|
|
184 |
{
|
|
|
185 |
cacheImage = (ListeImageCarnet)o ;
|
|
|
186 |
}
|
|
|
187 |
|
|
|
188 |
/**
|
|
|
189 |
* Met à jour l'arbre des mots clés à partir d'un objet
|
|
|
190 |
* @param o le nouvel arbre de mots clés
|
|
|
191 |
*/
|
|
|
192 |
public void rafraichirArbreMotsCles(Object o)
|
|
|
193 |
{
|
|
|
194 |
arbreMotsCles = (com.gwtext.client.data.Tree)o ;
|
|
|
195 |
}
|
|
|
196 |
|
|
|
197 |
/**
|
|
|
198 |
* Met à jour la table de correspondance mots clés / ids
|
|
|
199 |
* à partir d'un objet
|
|
|
200 |
* @param o la nouvelle table des mots clés
|
|
|
201 |
*/
|
|
|
202 |
@SuppressWarnings("unchecked")
|
|
|
203 |
public void rafraichirMotsCles(Object o)
|
|
|
204 |
{
|
|
|
205 |
if(o instanceof HashMap)
|
|
|
206 |
{
|
|
|
207 |
motsCles = (HashMap<String, String>)o ;
|
|
|
208 |
}
|
|
|
209 |
}
|
|
|
210 |
|
|
|
211 |
/**
|
|
|
212 |
* Va chercher les métadonnées associées à une image dans la liste
|
|
|
213 |
* des images chargée dans le modèle
|
|
|
214 |
* @param r le rafraichissable auquel on enverra les informations
|
|
|
215 |
* @param id l'identifiant de l'image
|
|
|
216 |
*/
|
|
|
217 |
public void obtenirMetadonnees(Rafraichissable r, String id)
|
|
|
218 |
{
|
|
|
219 |
ImageCarnet im = (ImageCarnet)cacheImage.get(id) ;
|
|
|
220 |
|
|
|
221 |
Object meta[] = new Object[3] ;
|
|
|
222 |
meta[0] = im.getMetadonnesExif() ;
|
|
|
223 |
meta[1] = im.getMetadonnesIptc() ;
|
|
|
224 |
meta[2] = im.getInfoGenerales() ;
|
|
|
225 |
|
|
|
226 |
r.rafraichir(meta,false) ;
|
|
|
227 |
}
|
|
|
228 |
|
|
|
229 |
/**
|
|
|
230 |
* Va chercher les mots clés associés à une image dans la liste
|
|
|
231 |
* des images chargée dans le modèle
|
|
|
232 |
* @param r le rafraichissable auquel on enverra les informations
|
|
|
233 |
* @param id l'identifiant de l'image
|
|
|
234 |
*/
|
|
|
235 |
public void obtenirMotsClesId(Rafraichissable r, String id)
|
|
|
236 |
{
|
|
|
237 |
ImageCarnet im = cacheImage.get(id) ;
|
|
|
238 |
String motsClesId = im.getMotsCles() ;
|
|
|
239 |
String[] motsClesIdTab = motsClesId.split(",") ;
|
|
|
240 |
|
|
|
241 |
r.rafraichir(motsClesIdTab, false) ;
|
|
|
242 |
}
|
|
|
243 |
|
|
|
244 |
/**
|
|
|
245 |
* Met à jour la liste des images en local et appelle le DAO de mise
|
|
|
246 |
* à jour pour les commentaires et la date des images selectionnées
|
|
|
247 |
* @param commentaires le commentaire à appliquer
|
|
|
248 |
* @param date la date à appliquer
|
|
|
249 |
* @param ids les identifiants des images selectionnées
|
|
|
250 |
*/
|
|
|
251 |
public void mettreAJourCacheImage(String commentaires, String date, String note, String ids[])
|
|
|
252 |
{
|
|
|
253 |
for (int i = 0; i < ids.length; i++)
|
|
|
254 |
{
|
|
|
255 |
String key = ids[i] ;
|
|
|
256 |
ImageCarnet ic = cacheImage.get(key) ;
|
|
|
257 |
ic.miseAJourInfoGenerales(commentaires, date, note) ;
|
|
|
258 |
mettreAjourBaseDeDonneesImageCarnet(ic) ;
|
|
|
259 |
}
|
|
|
260 |
|
|
|
261 |
}
|
|
|
262 |
|
|
|
263 |
/**
|
|
|
264 |
* Ajoute un nouveau mot clés à la liste des mots clés locale
|
|
|
265 |
* @param text le mot clé
|
|
|
266 |
* @param id l'identifiant du mot clé
|
|
|
267 |
*/
|
|
|
268 |
public void mettreAjourMotsClesId(String text, String id)
|
|
|
269 |
{
|
|
|
270 |
motsCles.put(id, text) ;
|
|
|
271 |
}
|
|
|
272 |
|
|
|
273 |
/**
|
|
|
274 |
* Appelle le DAO chargé de mettre à jour la base de données avec
|
|
|
275 |
* les toutes les informations des images modifiées par l'utilisateur
|
|
|
276 |
*/
|
|
|
277 |
public void mettreAJourBaseDeDonneesListeImageCarnet()
|
|
|
278 |
{
|
|
|
279 |
ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
|
|
|
280 |
|
|
|
281 |
liDaO.SynchroniserBaseDeDonnees(cacheImage);
|
|
|
282 |
}
|
|
|
283 |
|
|
|
284 |
/**
|
|
|
285 |
* Appelle le DAO chargé de mettre à jour la base de données avec
|
|
|
286 |
* les toutes les informations d'une image donnée
|
|
|
287 |
* @param ic l'image à synchroniser avec la base
|
|
|
288 |
*/
|
|
|
289 |
public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic)
|
|
|
290 |
{
|
|
|
291 |
ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
|
|
|
292 |
iaDaO.SynchroniserBaseDeDonnees(ic) ;
|
|
|
293 |
}
|
|
|
294 |
|
|
|
295 |
/**
|
|
|
296 |
* Supprime les images données du cache local et appelle le DAO
|
|
|
297 |
* qui les supprime de la base de données
|
|
|
298 |
* @param ids les identifiants des images selectionnées
|
|
|
299 |
*/
|
|
|
300 |
public void supprimerImages(String[] ids)
|
|
|
301 |
{
|
|
|
302 |
String rids[] = new String[ids.length] ;
|
|
|
303 |
ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this) ;
|
|
|
304 |
|
|
|
305 |
for (int i = 0; i < ids.length; i++)
|
|
|
306 |
{
|
|
|
307 |
String key = ids[i] ;
|
|
|
308 |
ImageCarnet ic = cacheImage.get(key) ;
|
|
|
309 |
rids[i] = ic.getId() ;
|
|
|
310 |
|
|
|
311 |
cacheImage.remove(key) ;
|
|
|
312 |
}
|
|
|
313 |
|
|
|
314 |
if(rids.length != 0)
|
|
|
315 |
{
|
|
|
316 |
liDao.supprimerBaseDeDonnees(rids);
|
|
|
317 |
}
|
|
|
318 |
}
|
|
|
319 |
|
|
|
320 |
/**
|
|
|
321 |
* Met à jour les données locales suivant le type des nouvelles données
|
|
|
322 |
* et appelle le médiateur pour le notifier de la mise à jour
|
|
|
323 |
*/
|
|
|
324 |
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement)
|
|
|
325 |
{
|
|
|
326 |
// si l'on a reçu une liste d'images
|
|
|
327 |
if(nouvelleDonnees instanceof ListeImageCarnet)
|
|
|
328 |
{
|
|
|
329 |
ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ;
|
|
|
330 |
Object[][] photoData = new Object[data.size()][8];
|
|
|
331 |
int i = 0 ;
|
|
|
332 |
|
|
|
333 |
if(data.size() == 0)
|
|
|
334 |
{
|
|
|
335 |
pageEncours = 0 ;
|
|
|
336 |
}
|
|
|
337 |
|
|
|
338 |
// on la parse et on récupère les informations quiç nous interessent
|
|
|
339 |
for (Iterator<String> it = data.keySet().iterator(); it.hasNext();)
|
|
|
340 |
{
|
|
|
341 |
ImageCarnet im = data.get(it.next());
|
|
|
342 |
photoData[i][0] = im.getOrdre() ;
|
|
|
343 |
photoData[i][1] = im.getDate() ;
|
|
|
344 |
photoData[i][2] = im.getIptcCity() ;
|
|
|
345 |
photoData[i][3] = im.getMake()+" "+im.getModel() ;
|
|
|
346 |
photoData[i][4] = im.getSUrl() ;
|
|
|
347 |
photoData[i][5] = im.getMUrl() ;
|
|
|
348 |
photoData[i][6] = im.getLUrl() ;
|
|
|
349 |
photoData[i][7] = im.getNote() ;
|
|
|
350 |
|
|
|
351 |
i++ ;
|
|
|
352 |
}
|
|
|
353 |
|
|
|
354 |
// creation du store qui les contient
|
|
|
355 |
FieldDef defNumImage = new IntegerFieldDef("num_image");
|
|
|
356 |
FieldDef defDatImage = new StringFieldDef("dat_image");
|
|
|
357 |
FieldDef defLieImage = new StringFieldDef("lie_image");
|
|
|
358 |
FieldDef defAppImage = new StringFieldDef("app_image");
|
|
|
359 |
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
|
|
|
360 |
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
|
|
|
361 |
FieldDef defUrlImage = new StringFieldDef("url_image");
|
|
|
362 |
FieldDef defNoteImage = new IntegerFieldDef("note_image") ;
|
|
|
363 |
FieldDef[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage,defNoteImage};
|
|
|
364 |
RecordDef rd = new RecordDef(defTab) ;
|
|
|
365 |
|
|
|
366 |
final MemoryProxy dataProxy = new MemoryProxy(photoData);
|
|
|
367 |
final ArrayReader reader = new ArrayReader(rd);
|
|
|
368 |
|
|
|
369 |
final Store photoStore = new Store(dataProxy, reader);
|
|
|
370 |
|
|
|
371 |
rafraichirListeImage(nouvelleDonnees);
|
|
|
372 |
|
|
|
373 |
st = photoStore ;
|
|
|
374 |
st.load() ;
|
|
|
375 |
|
|
|
376 |
// par défaut le store est trié sur le numéro d'image
|
|
|
377 |
st.sort("num_image") ;
|
|
|
378 |
|
|
|
379 |
|
|
|
380 |
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
|
|
|
381 |
if(repandreRafraichissement)
|
|
|
382 |
{
|
|
|
383 |
getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ;
|
|
|
384 |
}
|
|
|
385 |
}
|
|
|
386 |
|
|
|
387 |
// si on reçoit un tableau JSON
|
|
|
388 |
if(nouvelleDonnees instanceof JSONArray)
|
|
|
389 |
{
|
|
|
390 |
// alors on a reçu les informations sur les mots clés
|
|
|
391 |
JSONArray reponse = (JSONArray)nouvelleDonnees ;
|
|
|
392 |
|
|
|
393 |
final int taillemax = reponse.size();
|
|
|
394 |
|
|
|
395 |
// si le tableau est vide
|
|
|
396 |
if(taillemax == 0)
|
|
|
397 |
{
|
|
|
398 |
// on crée un arbre vide
|
|
|
399 |
TreeNode root = new TreeNode() ;
|
|
|
400 |
root.setId("racine") ;
|
|
|
401 |
root.setText("Tags") ;
|
|
|
402 |
String[] usObj = {"Tags","racine"} ;
|
|
|
403 |
root.setUserObject(usObj) ;
|
|
|
404 |
arbreMotsCles.setRootNode(root) ;
|
|
|
405 |
}
|
|
|
406 |
|
|
|
407 |
// pour chacun des élements du tableau
|
|
|
408 |
for (int j = 0; j < taillemax ; j++)
|
|
|
409 |
{
|
|
|
410 |
// on extrait les élements du tableau
|
|
|
411 |
if(reponse.get(j).isObject() != null)
|
|
|
412 |
{
|
|
|
413 |
JSONObject noeud = (JSONObject)reponse.get(j) ;
|
|
|
414 |
|
|
|
415 |
String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur").isString().stringValue() ;
|
|
|
416 |
String mot_cle = noeud.get("cmc_mot_cle").isString().stringValue() ;
|
|
|
417 |
String parent = noeud.get("cmc_id_parent").isString().stringValue() ;
|
|
|
418 |
|
|
|
419 |
String[] usObj = {mot_cle, id_noeud} ;
|
|
|
420 |
|
|
|
421 |
// et on construit l'arbre à partir de la racine (qui est toujoursl e premier élément)
|
|
|
422 |
if(id_noeud.equals("racine"))
|
|
|
423 |
{
|
|
|
424 |
TreeNode root = new TreeNode() ;
|
|
|
425 |
root.setId(id_noeud) ;
|
|
|
426 |
root.setText(mot_cle) ;
|
|
|
427 |
root.setUserObject(usObj) ;
|
|
|
428 |
arbreMotsCles.setRootNode(root) ;
|
|
|
429 |
}
|
|
|
430 |
else
|
|
|
431 |
{
|
|
|
432 |
// et en ajoutant les noeuds un à un (qui sont renvoyé dans l'ordre hierarchique de leur niveau
|
|
|
433 |
// ce qui permet de les traiter séquentiellement)
|
|
|
434 |
TreeNode node = new TreeNode() ;
|
|
|
435 |
node.setId(id_noeud) ;
|
|
|
436 |
node.setText(mot_cle) ;
|
|
|
437 |
node.setChecked(false) ;
|
|
|
438 |
Node parentNode = arbreMotsCles.getNodeById(parent) ;
|
|
|
439 |
node.setUserObject(usObj) ;
|
|
|
440 |
parentNode.appendChild(node) ;
|
|
|
441 |
}
|
|
|
442 |
}
|
|
|
443 |
}
|
|
|
444 |
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
|
|
|
445 |
rafraichirArbreMotsCles(arbreMotsCles) ;
|
|
|
446 |
// et on notifie le médiateur de la mise à jour en lui passant une copie des données
|
|
|
447 |
getIMediateur().rafraichirArbreMotsCles(arbreMotsCles) ;
|
|
|
448 |
}
|
|
|
449 |
|
|
|
450 |
// Si on reçoit un tableau d'entiers
|
|
|
451 |
// c'est un tableau d'un seul entier qui est le nombre d'images correspondant aux critères
|
|
|
452 |
if(nouvelleDonnees instanceof int[])
|
|
|
453 |
{
|
|
|
454 |
int[] pages = (int[])nouvelleDonnees ;
|
|
|
455 |
|
|
|
456 |
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
|
|
|
457 |
pageMax = calculerNbPages(pages[0]) ;
|
|
|
458 |
nbElements = pages[0] ;
|
|
|
459 |
|
|
|
460 |
// et on notifie de le mediateur du changement des valeurs
|
|
|
461 |
getIMediateur().changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
|
|
|
462 |
}
|
|
|
463 |
}
|
|
|
464 |
|
|
|
465 |
/**
|
|
|
466 |
* Affiche les paires / valeur de tous les mots clés stockés
|
|
|
467 |
*/
|
|
|
468 |
public void afficherMotsCles()
|
|
|
469 |
{
|
|
|
470 |
for(Iterator<String> it = motsCles.keySet().iterator() ; it.hasNext() ;)
|
|
|
471 |
{
|
|
|
472 |
String key = it.next() ;
|
|
|
473 |
String valeur = (String)motsCles.get(key) ;
|
|
|
474 |
System.out.println("clé : "+key+" valeur : "+valeur);
|
|
|
475 |
}
|
|
|
476 |
}
|
|
|
477 |
|
|
|
478 |
/**
|
|
|
479 |
* Met à jour les mots clés associés à une image et appelle le DAO pour synchroniser la base de données
|
|
|
480 |
* @param ids les identifiants des images selectionnées
|
|
|
481 |
* @param motsClesEnCours les mots clés à appliquer aux images
|
|
|
482 |
* @param arbreMC l'arbre de mots clés en cours
|
|
|
483 |
*/
|
|
|
484 |
public void mettreAjourMotsCles(String[] ids, String motsClesEnCours, com.gwtext.client.data.Tree arbreMC)
|
|
|
485 |
{
|
|
|
486 |
for (int i = 0; i < ids.length; i++)
|
|
|
487 |
{
|
|
|
488 |
if(cacheImage.containsKey(ids[i]))
|
|
|
489 |
{
|
|
|
490 |
ImageCarnet ic = (ImageCarnet)cacheImage.get(ids[i]) ;
|
|
|
491 |
ic.mettreAjourMotsCles(motsClesEnCours) ;
|
|
|
492 |
|
|
|
493 |
ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this) ;
|
|
|
494 |
imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic) ;
|
|
|
495 |
}
|
|
|
496 |
}
|
|
|
497 |
|
|
|
498 |
rafraichirArbreMotsCles(arbreMC) ;
|
|
|
499 |
}
|
|
|
500 |
|
|
|
501 |
|
|
|
502 |
/**
|
|
|
503 |
* Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la base de données
|
|
|
504 |
*/
|
|
|
505 |
public void initialiserArbreMotsCles()
|
|
|
506 |
{
|
|
|
507 |
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
|
|
|
508 |
MCDao.obtenirListeMotsCles(this) ;
|
|
|
509 |
}
|
|
|
510 |
|
|
|
511 |
/**
|
|
|
512 |
* Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable donné, qui le demande
|
|
|
513 |
* @param r le rafraichissable demandeur de l'arbre
|
|
|
514 |
*/
|
|
|
515 |
public void obtenirArbreMotCle(Rafraichissable r)
|
|
|
516 |
{
|
|
|
517 |
r.rafraichir(arbreMotsCles, false) ;
|
|
|
518 |
}
|
|
|
519 |
|
|
|
520 |
/**
|
|
|
521 |
* Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui fait la mise
|
|
|
522 |
* à jour de l'arbre des mots clés dans la base
|
|
|
523 |
* @param n le nouveau noeud contenant le mot clé
|
|
|
524 |
* @param arbreMC l'arbre des mots cles en cours
|
|
|
525 |
*/
|
|
|
526 |
public void ajouterMotCleDansArbre(TreeNode n, com.gwtext.client.data.Tree arbreMC)
|
|
|
527 |
{
|
|
|
528 |
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
|
|
|
529 |
|
|
|
530 |
String[] usObj = (String[])n.getUserObject() ;
|
|
|
531 |
String motCle = usObj[0] ;
|
|
|
532 |
String id = usObj[1] ;
|
|
|
533 |
String parentId = "" ;
|
|
|
534 |
|
|
|
535 |
if(!id.equals("racine"))
|
|
|
536 |
{
|
|
|
537 |
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
|
|
|
538 |
parentId = parentUsObj[1] ;
|
|
|
539 |
}
|
|
|
540 |
else
|
|
|
541 |
{
|
|
|
542 |
parentId = "racine" ;
|
|
|
543 |
}
|
|
|
544 |
|
|
|
545 |
rafraichirArbreMotsCles(arbreMC) ;
|
|
|
546 |
|
|
|
547 |
String nouveauMotCle = "&identifiant="+getIdentifiant()+"&motcle="+motCle+"&id="+id+"&parent="+parentId ;
|
|
|
548 |
MCDao.ajouterBaseDeDonnees(nouveauMotCle) ;
|
|
|
549 |
}
|
|
|
550 |
|
|
|
551 |
/**
|
|
|
552 |
* Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va supprimer
|
|
|
553 |
* les mots clés associés dans la base
|
|
|
554 |
* @param n le noeud à supprimer
|
|
|
555 |
* @param arbreMC l'arbre des mots clés en cours
|
|
|
556 |
*/
|
|
|
557 |
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC)
|
|
|
558 |
{
|
|
|
559 |
|
|
|
560 |
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
|
|
|
561 |
|
|
|
562 |
String[] usObj = (String[])n.getUserObject() ;
|
|
|
563 |
String id = usObj[1] ;
|
|
|
564 |
|
|
|
565 |
MCDao.supprimerBaseDeDonnees(id) ;
|
|
|
566 |
|
|
|
567 |
}
|
|
|
568 |
|
|
|
569 |
/**
|
|
|
570 |
* Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le DAO
|
|
|
571 |
* qui synchronise la modification dans la base de données
|
|
|
572 |
* @param n le noeud modifié
|
|
|
573 |
* @param arbreMC l'arbre des mots clés en cours
|
|
|
574 |
*/
|
|
|
575 |
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC)
|
|
|
576 |
{
|
|
|
577 |
|
|
|
578 |
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
|
|
|
579 |
|
|
|
580 |
String[] usObj = (String[])n.getUserObject() ;
|
|
|
581 |
String motCle = usObj[0] ;
|
|
|
582 |
String id = usObj[1] ;
|
|
|
583 |
String parentId = "" ;
|
|
|
584 |
|
|
|
585 |
if(!id.equals("racine"))
|
|
|
586 |
{
|
|
|
587 |
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
|
|
|
588 |
parentId = parentUsObj[1] ;
|
|
|
589 |
}
|
|
|
590 |
else
|
|
|
591 |
{
|
|
|
592 |
parentId = "racine" ;
|
|
|
593 |
}
|
|
|
594 |
|
|
|
595 |
rafraichirArbreMotsCles(arbreMC) ;
|
|
|
596 |
|
|
|
597 |
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
|
|
|
598 |
MCDao.modifierBaseDeDonnees(motCleModifie) ;
|
|
|
599 |
|
|
|
600 |
}
|
|
|
601 |
|
|
|
602 |
/**
|
|
|
603 |
* Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui reorganise l'arbre
|
|
|
604 |
* dans la base de donnees suivant le changement
|
|
|
605 |
* @param n le noeud deplace (et son sous arbre associe)
|
|
|
606 |
* @param arbreMC l'arbre des mots cles en cours
|
|
|
607 |
*/
|
|
|
608 |
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC)
|
|
|
609 |
{
|
|
|
610 |
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
|
|
|
611 |
|
|
|
612 |
String[] usObj = (String[])n.getUserObject() ;
|
|
|
613 |
String motCle = usObj[0] ;
|
|
|
614 |
String id = usObj[1] ;
|
|
|
615 |
String parentId = "" ;
|
|
|
616 |
if(!id.equals("racine"))
|
|
|
617 |
{
|
|
|
618 |
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
|
|
|
619 |
parentId = parentUsObj[1] ;
|
|
|
620 |
}
|
|
|
621 |
else
|
|
|
622 |
{
|
|
|
623 |
parentId = "racine" ;
|
|
|
624 |
}
|
|
|
625 |
|
|
|
626 |
rafraichirArbreMotsCles(arbreMC) ;
|
|
|
627 |
|
|
|
628 |
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
|
|
|
629 |
MCDao.deplacerBaseDeDonnees(motCleModifie) ;
|
|
|
630 |
}
|
|
|
631 |
|
|
|
632 |
/**
|
|
|
633 |
* Change le numéro de la page en cours et envoie une demande de mise à jour des données
|
|
|
634 |
* @param nouvellePageCourante la nouvelle page à afficher
|
|
|
635 |
*/
|
|
|
636 |
public void changerNumeroPage(int nouvellePageCourante)
|
|
|
637 |
{
|
|
|
638 |
pageEncours = nouvellePageCourante ;
|
|
|
639 |
obtenirPhotoGalerie(this) ;
|
|
|
640 |
}
|
|
|
641 |
|
|
|
642 |
/**
|
|
|
643 |
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
|
|
|
644 |
* en cours
|
|
|
645 |
* @param nbElements le nombre d'élements total
|
|
|
646 |
* @return le nombre de pages
|
|
|
647 |
*/
|
|
|
648 |
public int calculerNbPages(int nbElements)
|
|
|
649 |
{
|
|
|
650 |
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
|
|
|
651 |
// pour eviter qu'il arrondisse mal la division
|
|
|
652 |
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
|
|
|
653 |
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
|
|
|
654 |
double nPageRound = Math.ceil(nPage) ;
|
|
|
655 |
Double nPageInt = new Double(nPageRound) ;
|
|
|
656 |
|
|
|
657 |
// on convertit en entier
|
|
|
658 |
return nPageInt.intValue() ;
|
|
|
659 |
}
|
|
|
660 |
|
|
|
661 |
/**
|
|
|
662 |
* Recalcule la page en cours lors du changement du nombre d'élements
|
|
|
663 |
* @param nbElements le nombre d'élements total
|
|
|
664 |
* @return la nouvelle page encours
|
|
|
665 |
*/
|
|
|
666 |
public int calculerPageCourante(int nbElements)
|
|
|
667 |
{
|
|
|
668 |
// on calcule le nombre de page
|
|
|
669 |
int nouvelNbPages = calculerNbPages(nbElements) ;
|
|
|
670 |
// la nouvelle page en cours
|
|
|
671 |
double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
|
|
|
672 |
|
|
|
673 |
// on arrondit au supérieur
|
|
|
674 |
double nPageRound = Math.ceil(nPageCourante) ;
|
|
|
675 |
Double nPageInt = new Double(nPageRound) ;
|
|
|
676 |
|
|
|
677 |
// on convertit en entier
|
|
|
678 |
return Math.abs(nPageInt.intValue()) ;
|
|
|
679 |
}
|
|
|
680 |
|
|
|
681 |
/**
|
|
|
682 |
* Change la taille de page et recalcule la page encours
|
|
|
683 |
* @param nouvelleTaillePage la nouvelle taille de page à utiliser
|
|
|
684 |
*/
|
|
|
685 |
public void changerTaillePage(int nouvelleTaillePage)
|
|
|
686 |
{
|
|
|
687 |
taillePage = nouvelleTaillePage ;
|
|
|
688 |
pageEncours = calculerPageCourante(nbElements) ;
|
|
|
689 |
obtenirPhotoGalerie(this) ;
|
|
|
690 |
}
|
|
|
691 |
|
|
|
692 |
/**
|
|
|
693 |
* Notifie le mediateur que l'upload ou le download est termine et qu'il faut rafraichir les vues avec les nouvelles données
|
|
|
694 |
*/
|
|
|
695 |
public void requeteTerminee()
|
|
|
696 |
{
|
|
|
697 |
getIMediateur().demasquerChargement() ;
|
|
|
698 |
getIMediateur().rafraichirToutesVues() ;
|
|
|
699 |
}
|
|
|
700 |
|
|
|
701 |
/**
|
|
|
702 |
* Obtient l'identifiant de l'utilisateur auprès du médiateur
|
|
|
703 |
* @return id de l'utilisateur
|
|
|
704 |
*/
|
|
|
705 |
public String getIdentifiant() {
|
|
|
706 |
|
|
|
707 |
return getIMediateur().getIdentifiant() ;
|
|
|
708 |
}
|
|
|
709 |
|
|
|
710 |
/**
|
|
|
711 |
* renvoie la taille d'une image grâce à son identifiant
|
|
|
712 |
* @param id l'identifiant de l'image
|
|
|
713 |
* @return un tableau contenant la longueur et la hauteur de l'image
|
|
|
714 |
*/
|
|
|
715 |
public String[] obtenirTailleImage(String id) {
|
|
|
716 |
|
|
|
717 |
return (cacheImage.get(id)).getTailleImage() ;
|
|
|
718 |
|
|
|
719 |
}
|
|
|
720 |
|
|
|
721 |
/**
|
|
|
722 |
* Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
|
|
|
723 |
* renvoie la note associée au rafrachissable qui la demande
|
|
|
724 |
* @param r le rafraichissable demandeur de l'information
|
|
|
725 |
* @param id l'identifiant del'image
|
|
|
726 |
*/
|
|
|
727 |
public void obtenirNote(Rafraichissable r, String id) {
|
|
|
728 |
|
|
|
729 |
r.rafraichir((cacheImage.get(id)).getNote() ,true) ;
|
|
|
730 |
|
|
|
731 |
}
|
|
|
732 |
|
|
|
733 |
/**
|
|
|
734 |
* Accesseur pour la configuration en cours d'utilisation
|
|
|
735 |
* @return la configuration
|
|
|
736 |
*/
|
|
|
737 |
public Configuration getConfig() {
|
|
|
738 |
|
|
|
739 |
return config ;
|
|
|
740 |
}
|
|
|
741 |
|
|
|
742 |
}
|