Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 4 → Rev 5

/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,716 → 29,821
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
*
*
*/
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 ;
private static boolean estInstancie = false;
 
/**
* le modèle lui même
*/
private static ImageModele thisModele = null ;
private static ImageModele thisModele = null;
 
/**
* Le médiateur associé au modèle
*/
private ImageMediateur iMediateur = null ;
private ImageMediateur iMediateur = null;
 
/**
* La configuration en cours
*/
private Configuration config = null ;
private Configuration config = null;
 
/**
* La liste des image affichées en cours
*/
private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;
private ListeImageCarnet cacheImage = new ListeImageCarnet(0);
/**
* Table de correspondance entre les mots clés et leurs identifiants
*/
private HashMap<String, String> motsCles = new HashMap<String, String>(0) ;
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 ;
private Store st = null;
/**
* Arbre des mots clés
*/
private com.gwtext.client.data.Tree arbreMotsCles = new Tree() ;
private com.gwtext.client.data.Tree arbreMotsCles = new Tree();
 
/**
* Numéro de page en cours
*/
private int pageEncours = 0 ;
private int pageEncours = 0;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
private int pageMax = 1;
/**
* Taille de page (par défaut 50)
*/
private int taillePage = 50 ;
private int taillePage = 50;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
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 ;
estInstancie = true;
thisModele = new ImageModele(im);
}
 
// sinon on retourne le "pointeur" vers le modèle lui-même
return thisModele ;
return thisModele;
 
}
 
/**
* 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) {
iMediateur = im ;
config = new Configuration() ;
 
iMediateur = im;
config = new Configuration();
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur()
{
return iMediateur ;
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 obtenirNombrePhotoGalerie(Rafraichissable r) {
 
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
 
int tailleFiltres = valeursFiltres.length;
 
String[][] criteres = new String[tailleFiltres + 1][2];
 
String[] utilisateur = { "ci_ce_utilisateur",
"" + getIMediateur().getIdentifiant() };
criteres[0] = utilisateur;
 
 
for (int i = 0; i < valeursFiltres.length; i++) {
criteres[i + 1] = valeursFiltres[i];
}
 
// on les crée un DAO auquel on les transmet et qui demande le nombre
// d'images correspondantes (pour les pages)
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
niaDAO.obtenirNombreImages(this, criteres);
}
public void obtenirPhotoGalerie(Rafraichissable r)
{
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;
int tailleFiltres = valeursFiltres.length;
int tailleFiltres = motsClesFiltres.length ;
String[][] criteres = new String[tailleFiltres+1][2] ;
String[][] criteres2 = new String[tailleFiltres+2][2] ;
String[][] criteres2 = new String[tailleFiltres + 2][2];
String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ;
criteres[0] = utilisateur ;
String[] limite = { "ci_limite", "" + taillePage };
String[] taillePage = { "ci_numero_page", "" + pageEncours };
String[] limite = {"ci_limite" ,""+taillePage } ;
String[] taillePage = {"ci_numero_page",""+pageEncours} ;
criteres2[0] = limite ;
criteres2[1] = taillePage ;
for (int i = 0 ; i < motsClesFiltres.length; i++) {
criteres[i+1] = motsClesFiltres[i] ;
criteres2[i+2] = motsClesFiltres[i] ;
criteres2[0] = limite;
criteres2[1] = taillePage;
 
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);
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()
{
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this) ;
IuADaO.choisirMethodeUpload() ;
public void uploaderImages() {
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
IuADaO.choisirMethodeUpload();
}
 
/**
* Met à jour la liste des images à partir d'un objet
* @param o la nouvelle liste d'image
*
* @param o
* la nouvelle liste d'image
*/
public void rafraichirListeImage(Object o)
{
cacheImage = (ListeImageCarnet)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)
{
arbreMotsCles = (com.gwtext.client.data.Tree)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)
{
motsCles = (HashMap<String, String>)o ;
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)
{
ImageCarnet im = (ImageCarnet)cacheImage.get(id) ;
Object meta[] = new Object[3] ;
meta[0] = im.getMetadonnesExif() ;
meta[1] = im.getMetadonnesIptc() ;
meta[2] = im.getInfoGenerales() ;
r.rafraichir(meta,false) ;
public void obtenirMetadonnees(Rafraichissable r, String id) {
ImageCarnet im = (ImageCarnet) cacheImage.get(id);
 
Object meta[] = new Object[3];
meta[0] = im.getMetadonnesExif();
meta[1] = im.getMetadonnesIptc();
meta[2] = im.getInfoGenerales();
 
r.rafraichir(meta, false);
}
 
/**
* Va chercher les mots clés associés à une image dans la liste
* des images chargée dans le modèle
* @param r le rafraichissable auquel on enverra les informations
* @param id l'identifiant de l'image
* Va chercher les mots clés associés à une image dans la liste des images
* chargée dans le modèle
*
* @param r
* le rafraichissable auquel on enverra les informations
* @param id
* l'identifiant de l'image
*/
public void obtenirMotsClesId(Rafraichissable r, String id)
{
ImageCarnet im = cacheImage.get(id) ;
String motsClesId = im.getMotsCles() ;
String[] motsClesIdTab = motsClesId.split(",") ;
r.rafraichir(motsClesIdTab, false) ;
public void obtenirMotsClesId(Rafraichissable r, String id) {
ImageCarnet im = cacheImage.get(id);
String motsClesId = im.getMotsCles();
String[] motsClesIdTab = motsClesId.split(",");
 
r.rafraichir(motsClesIdTab, false);
}
 
/**
* Met à jour la liste des images en local et appelle le DAO de mise
* à jour pour les commentaires et la date des images selectionnées
* @param commentaires le commentaire à appliquer
* @param date la date à appliquer
* @param ids les identifiants des images selectionnées
* Met à jour la liste des images en local et appelle le DAO de mise à jour
* pour les commentaires et la date des images selectionnées
*
* @param commentaires
* le commentaire à appliquer
* @param date
* la date à appliquer
* @param ids
* les identifiants des images selectionnées
*/
public void mettreAJourCacheImage(String commentaires, String date, String note, String ids[])
{
for (int i = 0; i < ids.length; i++)
{
String key = ids[i] ;
ImageCarnet ic = cacheImage.get(key) ;
ic.miseAJourInfoGenerales(commentaires, date, note) ;
mettreAjourBaseDeDonneesImageCarnet(ic) ;
}
public void mettreAJourCacheImage(String commentaires, String date,
String note, String ids[]) {
for (int i = 0; i < ids.length; i++) {
String key = ids[i];
ImageCarnet ic = cacheImage.get(key);
ic.miseAJourInfoGenerales(commentaires, date, note);
mettreAjourBaseDeDonneesImageCarnet(ic);
}
 
}
 
/**
* Ajoute un nouveau mot clés à la liste des mots clés locale
* @param text le mot clé
* @param id l'identifiant du mot clé
*
* @param text
* le mot clé
* @param id
* l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id)
{
motsCles.put(id, text) ;
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);
}
 
/**
* 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) ;
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)
{
String rids[] = new String[ids.length] ;
ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this) ;
for (int i = 0; i < ids.length; i++)
{
String key = ids[i] ;
ImageCarnet ic = cacheImage.get(key) ;
rids[i] = ic.getId() ;
cacheImage.remove(key) ;
public void supprimerImages(String[] ids) {
String rids[] = new String[ids.length];
ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
 
for (int i = 0; i < ids.length; i++) {
String key = ids[i];
ImageCarnet ic = cacheImage.get(key);
rids[i] = ic.getId();
 
cacheImage.remove(key);
}
if(rids.length != 0)
{
 
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)
{
ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ;
Object[][] photoData = new Object[data.size()][8];
int i = 0 ;
if(data.size() == 0)
{
pageEncours = 0 ;
}
// on la parse et on récupère les informations quiç nous interessent
for (Iterator<String> it = data.keySet().iterator(); it.hasNext();)
{
ImageCarnet im = data.get(it.next());
photoData[i][0] = im.getOrdre() ;
photoData[i][1] = im.getDate() ;
photoData[i][2] = im.getIptcCity() ;
photoData[i][3] = im.getMake()+" "+im.getModel() ;
photoData[i][4] = im.getSUrl() ;
photoData[i][5] = im.getMUrl() ;
photoData[i][6] = im.getLUrl() ;
photoData[i][7] = im.getNote() ;
i++ ;
}
// creation du store qui les contient
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new IntegerFieldDef("note_image") ;
FieldDef[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage,defNoteImage};
RecordDef rd = new RecordDef(defTab) ;
final MemoryProxy dataProxy = new MemoryProxy(photoData);
final ArrayReader reader = new ArrayReader(rd);
final Store photoStore = new Store(dataProxy, reader);
rafraichirListeImage(nouvelleDonnees);
st = photoStore ;
st.load() ;
// par défaut le store est trié sur le numéro d'image
st.sort("num_image") ;
if (nouvelleDonnees instanceof ListeImageCarnet) {
ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;
Object[][] photoData = new Object[data.size()][9];
int i = 0;
 
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
if(repandreRafraichissement)
{
getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ;
}
if (data.size() == 0) {
pageEncours = 0;
}
 
// on la parse et on récupère les informations quiç nous interessent
for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
ImageCarnet im = data.get(it.next());
photoData[i][0] = im.getOrdre();
photoData[i][1] = im.getDate();
photoData[i][2] = im.getIptcCity();
photoData[i][3] = im.getMake() + " " + im.getModel();
photoData[i][4] = im.getSUrl();
photoData[i][5] = im.getMUrl();
photoData[i][6] = im.getLUrl();
photoData[i][7] = im.getNote();
photoData[i][8] = im.getId();
 
i++;
}
 
// creation du store qui les contient
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new IntegerFieldDef("note_image");
FieldDef defIdImage = new IntegerFieldDef("id_image");
FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage, defIdImage };
RecordDef rd = new RecordDef(defTab);
 
final MemoryProxy dataProxy = new MemoryProxy(photoData);
final ArrayReader reader = new ArrayReader(rd);
 
final Store photoStore = new Store(dataProxy, reader);
 
rafraichirListeImage(nouvelleDonnees);
 
st = photoStore;
st.load();
 
// par défaut le store est trié sur le numéro d'image
st.sort("num_image");
 
// si on doit répandre les données, on notifie le médiateur qui les
// distribuera à son tour
if (repandreRafraichissement) {
getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
}
}
 
// si on reçoit un tableau JSON
if(nouvelleDonnees instanceof JSONArray)
{
if (nouvelleDonnees instanceof JSONArray) {
// alors on a reçu les informations sur les mots clés
JSONArray reponse = (JSONArray)nouvelleDonnees ;
JSONArray reponse = (JSONArray) nouvelleDonnees;
 
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") ;
root.setText("Tags") ;
String[] usObj = {"Tags","racine"} ;
root.setUserObject(usObj) ;
arbreMotsCles.setRootNode(root) ;
TreeNode root = new TreeNode();
root.setId("racine");
root.setText("Tags");
String[] usObj = { "Tags", "racine" };
root.setUserObject(usObj);
arbreMotsCles.setRootNode(root);
}
 
// pour chacun des élements du tableau
for (int j = 0; j < taillemax ; j++)
{
for (int j = 0; j < taillemax; j++) {
// on extrait les élements du tableau
if(reponse.get(j).isObject() != null)
{
JSONObject noeud = (JSONObject)reponse.get(j) ;
String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur").isString().stringValue() ;
String mot_cle = noeud.get("cmc_mot_cle").isString().stringValue() ;
String parent = noeud.get("cmc_id_parent").isString().stringValue() ;
String[] usObj = {mot_cle, id_noeud} ;
// et on construit l'arbre à partir de la racine (qui est toujoursl e premier élément)
if(id_noeud.equals("racine"))
{
TreeNode root = new TreeNode() ;
root.setId(id_noeud) ;
root.setText(mot_cle) ;
root.setUserObject(usObj) ;
arbreMotsCles.setRootNode(root) ;
}
else
{
// et en ajoutant les noeuds un à un (qui sont renvoyé dans l'ordre hierarchique de leur niveau
if (reponse.get(j).isObject() != null) {
JSONObject noeud = (JSONObject) reponse.get(j);
 
String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")
.isString().stringValue();
String mot_cle = noeud.get("cmc_mot_cle").isString()
.stringValue();
String parent = noeud.get("cmc_id_parent").isString()
.stringValue();
 
String[] usObj = { mot_cle, id_noeud };
 
// et on construit l'arbre à partir de la racine (qui est
// toujoursl e premier élément)
if (id_noeud.equals("racine")) {
TreeNode root = new TreeNode();
root.setId(id_noeud);
root.setText(mot_cle);
root.setUserObject(usObj);
arbreMotsCles.setRootNode(root);
} else {
// et en ajoutant les noeuds un à un (qui sont renvoyé
// dans l'ordre hierarchique de leur niveau
// ce qui permet de les traiter séquentiellement)
TreeNode node = new TreeNode() ;
node.setId(id_noeud) ;
node.setText(mot_cle) ;
node.setChecked(false) ;
Node parentNode = arbreMotsCles.getNodeById(parent) ;
node.setUserObject(usObj) ;
parentNode.appendChild(node) ;
TreeNode node = new TreeNode();
node.setId(id_noeud);
node.setText(mot_cle);
node.setChecked(false);
Node parentNode = arbreMotsCles.getNodeById(parent);
node.setUserObject(usObj);
parentNode.appendChild(node);
}
}
}
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
rafraichirArbreMotsCles(arbreMotsCles) ;
// et on notifie le médiateur de la mise à jour en lui passant une copie des données
getIMediateur().rafraichirArbreMotsCles(arbreMotsCles) ;
}
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
rafraichirArbreMotsCles(arbreMotsCles);
// et on notifie le médiateur de la mise à jour en lui passant une
// copie des données
getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);
}
 
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'images correspondant aux critères
if(nouvelleDonnees instanceof int[])
{
int[] pages = (int[])nouvelleDonnees ;
// c'est un tableau d'un seul entier qui est le nombre d'images
// correspondant aux critères
if (nouvelleDonnees instanceof int[]) {
int[] pages = (int[]) nouvelleDonnees;
 
// on calcule le nombre de pages nécessaires et on les met à jour
// dans le modèle
pageMax = calculerNbPages(pages[0]);
nbElements = pages[0];
 
// et on notifie de le mediateur du changement des valeurs
getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
taillePage, pages[0]);
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
pageMax = calculerNbPages(pages[0]) ;
nbElements = pages[0] ;
// et on notifie de le mediateur du changement des valeurs
getIMediateur().changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
obtenirPhotoGalerie(this) ;
}
}
 
/**
* Affiche les paires / valeur de tous les mots clés stockés
*/
public void afficherMotsCles()
{
for(Iterator<String> it = motsCles.keySet().iterator() ; it.hasNext() ;)
{
String key = it.next() ;
String valeur = (String)motsCles.get(key) ;
System.out.println("clé : "+key+" valeur : "+valeur);
public void afficherMotsCles() {
for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
String key = it.next();
String valeur = (String) motsCles.get(key);
System.out.println("clé : " + key + " valeur : " + valeur);
}
}
 
/**
* Met à jour les mots clés associés à une image et appelle le DAO pour synchroniser la base de données
* @param ids les identifiants des images selectionnées
* @param motsClesEnCours les mots clés à appliquer aux images
* @param arbreMC l'arbre de mots clés en cours
* Met à jour les mots clés associés à une image et appelle le DAO pour
* synchroniser la base de données
*
* @param ids
* les identifiants des images selectionnées
* @param motsClesEnCours
* les mots clés à appliquer aux images
* @param arbreMC
* l'arbre de mots clés en cours
*/
public void mettreAjourMotsCles(String[] ids, String motsClesEnCours, com.gwtext.client.data.Tree arbreMC)
{
for (int i = 0; i < ids.length; i++)
{
if(cacheImage.containsKey(ids[i]))
{
ImageCarnet ic = (ImageCarnet)cacheImage.get(ids[i]) ;
ic.mettreAjourMotsCles(motsClesEnCours) ;
ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this) ;
imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic) ;
public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
com.gwtext.client.data.Tree arbreMC) {
for (int i = 0; i < ids.length; i++) {
if (cacheImage.containsKey(ids[i])) {
ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);
ic.mettreAjourMotsCles(motsClesEnCours);
 
ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this);
imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic);
}
}
rafraichirArbreMotsCles(arbreMC) ;
 
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()
{
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
MCDao.obtenirListeMotsCles(this) ;
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)
{
r.rafraichir(arbreMotsCles, false) ;
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)
{
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
String motCle = usObj[0] ;
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
public void ajouterMotCleDansArbre(TreeNode n,
com.gwtext.client.data.Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
 
if (!id.equals("racine")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
parentId = parentUsObj[1];
} else {
parentId = "racine";
}
else
{
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String nouveauMotCle = "&identifiant="+getIdentifiant()+"&motcle="+motCle+"&id="+id+"&parent="+parentId ;
MCDao.ajouterBaseDeDonnees(nouveauMotCle) ;
 
rafraichirArbreMotsCles(arbreMC);
 
String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
+ motCle + "&id=" + id + "&parent=" + parentId;
MCDao.ajouterBaseDeDonnees(nouveauMotCle);
}
 
/**
* Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va supprimer
* les mots clés associés dans la base
* @param n le noeud à supprimer
* @param arbreMC l'arbre des mots clés en cours
* Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
* supprimer les mots clés associés dans la base
*
* @param n
* le noeud à supprimer
* @param arbreMC
* l'arbre des mots clés en cours
*/
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC)
{
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
String id = usObj[1] ;
MCDao.supprimerBaseDeDonnees(id) ;
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
 
String[] usObj = (String[]) n.getUserObject();
String id = usObj[1];
 
MCDao.supprimerBaseDeDonnees(id);
 
}
 
/**
* Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le DAO
* qui synchronise la modification dans la base de données
* @param n le noeud modifié
* @param arbreMC l'arbre des mots clés en cours
* Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
* DAO qui synchronise la modification dans la base de données
*
* @param n
* le noeud modifié
* @param arbreMC
* l'arbre des mots clés en cours
*/
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC)
{
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
String motCle = usObj[0] ;
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
 
if (!id.equals("racine")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
parentId = parentUsObj[1];
} else {
parentId = "racine";
}
else
{
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
MCDao.modifierBaseDeDonnees(motCleModifie) ;
 
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.modifierBaseDeDonnees(motCleModifie);
 
}
 
/**
* Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui reorganise l'arbre
* dans la base de donnees suivant le changement
* @param n le noeud deplace (et son sous arbre associe)
* @param arbreMC l'arbre des mots cles en cours
* Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
* reorganise l'arbre dans la base de donnees suivant le changement
*
* @param n
* le noeud deplace (et son sous arbre associe)
* @param arbreMC
* l'arbre des mots cles en cours
*/
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC)
{
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;
String[] usObj = (String[])n.getUserObject() ;
String motCle = usObj[0] ;
String id = usObj[1] ;
String parentId = "" ;
if(!id.equals("racine"))
{
String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;
parentId = parentUsObj[1] ;
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
if (!id.equals("racine")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
parentId = parentUsObj[1];
} else {
parentId = "racine";
}
else
{
parentId = "racine" ;
}
rafraichirArbreMotsCles(arbreMC) ;
String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;
MCDao.deplacerBaseDeDonnees(motCleModifie) ;
 
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.deplacerBaseDeDonnees(motCleModifie);
}
 
/**
* Change le numéro de la page en cours et envoie une demande de mise à jour des données
* @param nouvellePageCourante la nouvelle page à afficher
* Change le numéro de la page en cours et envoie une demande de mise à jour
* des données
*
* @param nouvellePageCourante
* la nouvelle page à afficher
*/
public void changerNumeroPage(int nouvellePageCourante)
{
pageEncours = nouvellePageCourante ;
obtenirPhotoGalerie(this) ;
public void changerNumeroPage(int nouvellePageCourante) {
pageEncours = nouvellePageCourante;
obtenirNombrePhotoGalerie(this);
}
 
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
* 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
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
// nombre de pages = (nombre d'element / taille de la page) arrondie à
// l'entier superieur
double nPage = (1.0 * nbElements) / (1.0 * taillePage);
double nPageRound = Math.ceil(nPage);
Double nPageInt = new Double(nPageRound);
 
// on convertit en entier
return nPageInt.intValue() ;
return nPageInt.intValue();
}
 
/**
* 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) ;
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) ;
Double nPageInt = new Double(nPageRound) ;
double nPageRound = Math.ceil(nPageCourante);
Double nPageInt = new Double(nPageRound);
 
// on convertit en entier
return Math.abs(nPageInt.intValue()) ;
return Math.abs(nPageInt.intValue());
}
 
/**
* Change la taille de page et recalcule la page encours
* @param nouvelleTaillePage la nouvelle taille de page à utiliser
* Change la taille de page et recalcule la page encours
*
* @param nouvelleTaillePage
* la nouvelle taille de page à utiliser
*/
public void changerTaillePage(int nouvelleTaillePage)
{
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
obtenirPhotoGalerie(this) ;
public void changerTaillePage(int nouvelleTaillePage) {
taillePage = nouvelleTaillePage;
pageEncours = calculerPageCourante(nbElements);
obtenirNombrePhotoGalerie(this);
}
 
/**
* Notifie le mediateur que l'upload ou le download est termine et qu'il faut rafraichir les vues avec les nouvelles données
* Notifie le mediateur que l'upload ou le download est termine et qu'il
* faut rafraichir les vues avec les nouvelles données
*/
public void requeteTerminee()
{
getIMediateur().demasquerChargement() ;
getIMediateur().rafraichirToutesVues() ;
public void requeteTerminee() {
getIMediateur().demasquerChargement();
getIMediateur().rafraichirToutesVues();
}
 
/**
* Obtient l'identifiant de l'utilisateur auprès du médiateur
*
* @return id de l'utilisateur
*/
public String getIdentifiant() {
return getIMediateur().getIdentifiant() ;
 
return getIMediateur().getIdentifiant();
}
 
/**
* 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) {
return (cacheImage.get(id)).getTailleImage() ;
 
return (cacheImage.get(id)).getTailleImage();
 
}
 
/**
* Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
* 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) {
r.rafraichir((cacheImage.get(id)).getNote() ,true) ;
 
r.rafraichir((cacheImage.get(id)).getNote(), true);
 
}
 
/**
* Accesseur pour la configuration en cours d'utilisation
*
* @return la configuration
*/
public Configuration getConfig() {
 
return config;
}
 
/**
* Ajoute des images à la selection en cours
*
* @param ids
* les identifiants des images à ajouter
*/
public void ajouterImagesSelection(String[] ids) {
 
for (int i = 0; i < ids.length; i++) {
 
selectionImages.add(ids[i]);
}
}
 
/**
* Vide la selection en cours
*/
public void viderSelection() {
selectionImages.clear();
}
 
public String renvoyerSelection() {
 
String selection = "";
return config ;
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) ;
}
 
}