Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.image;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Vector;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.Configuration;

import org.tela_botanica.client.modeles.ImageAsynchroneDAO;

import org.tela_botanica.client.modeles.ImageCarnet;

import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;

import org.tela_botanica.client.modeles.LienImageAsynchroneDAO;

import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;

import org.tela_botanica.client.modeles.ListeImageCarnet;

import org.tela_botanica.client.modeles.ListeObservation;

import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;

import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;

import com.google.gwt.json.client.JSONArray;

import com.google.gwt.json.client.JSONObject;

import com.gwtext.client.data.ArrayReader;

import com.gwtext.client.data.FieldDef;

import com.gwtext.client.data.IntegerFieldDef;

import com.gwtext.client.data.MemoryProxy;

import com.gwtext.client.data.Node;

import com.gwtext.client.data.RecordDef;

import com.gwtext.client.data.Store;

import com.gwtext.client.data.StringFieldDef;

import com.gwtext.client.data.Tree;

import com.gwtext.client.widgets.tree.TreeNode;

/**

 * Modèle d'accès aux données pour les images. C'est un singleton

 *

 * @author aurelien

 *

 */

public class ImageModele implements Rafraichissable {

	/**

	 * Booleen indiquant si le médiateur est instancié (l'instance doit être

	 * unique donc le booleen est static)

	 */

	private static boolean estInstancie = false;

	/**

	 * le modèle lui même

	 */

	private static ImageModele thisModele = null;

	/**

	 * Le médiateur associé au modèle

	 */

	private ImageMediateur iMediateur = null;

	/**

	 * La configuration en cours

	 */

	private Configuration config = null;

	/**

	 * La liste des image affichées en cours

	 */

	private ListeImageCarnet cacheImage = new ListeImageCarnet(0);

	/**

	 * Table de correspondance entre les mots clés et leurs identifiants

	 */

	private HashMap<String, String> motsCles = new HashMap<String, String>(0);

	/**

	 * Le store contenant les données à afficher, que le modèle transmet au

	 * médiateur quand il le demande

	 */

	private Store st = null;

	/**

	 * Arbre des mots clés

	 */

	private com.gwtext.client.data.Tree arbreMotsCles = new Tree();

	/**

	 * Numéro de page en cours

	 */

	private int pageEncours = 0;

	/**

	 * Nombre de pages totales

	 */

	private int pageMax = 1;

	/**

	 * Taille de page (par défaut 50)

	 */

	private int taillePage = 50;

	/**

	 * Nombre d'éléments total correspondant à la requete

	 */

	private int nbElements = 0;

	/**

	 * "Presse papier" pour les images qui permet de garder en mémoire une

	 * sélection

	 */

	private Vector<String> selectionImages = new Vector<String>(0);

	/**

	 * Retourne une instance de manière unique

	 *

	 * @param im

	 *            le médiateur à associer

	 * @return l'instance du modèle

	 */

	static ImageModele Instance(ImageMediateur im) {

		// si le modèle n'est pas encore instancié

		if (!estInstancie) {

			// on en crée un nouveau

			estInstancie = true;

			thisModele = new ImageModele(im);

		}

		// sinon on retourne le "pointeur" vers le modèle lui-même

		return thisModele;

	}

	/**

	 * Le constructeur est privé et seule la méthode instance y accède

	 *

	 * @param im

	 *            le médiateur à associer

	 */

	private ImageModele(ImageMediateur im) {

		iMediateur = im;

		config = new Configuration();

	}

	/**

	 * Accesseur pour le médiateur

	 *

	 * @return le médiateur associé

	 */

	public ImageMediateur getIMediateur() {

		return iMediateur;

	}

	/**

	 * Appelle le DAO asynchrone pour obtenir la liste des images

	 *

	 * @param r

	 *            le rafraichissable auxquel on enverra les données

	 */

	public void obtenirNombrePhotoGalerie(Rafraichissable r) {

		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();

		int tailleFiltres = valeursFiltres.length;

		String[][] criteres = new String[tailleFiltres + 1][2];

		String[] utilisateur = { "ci_ce_utilisateur",

				"" + getIMediateur().getIdentifiant() };

		criteres[0] = utilisateur;

		for (int i = 0; i < valeursFiltres.length; i++) {

			criteres[i + 1] = valeursFiltres[i];

		}

		// on les crée un DAO auquel on les transmet et qui demande le nombre

		// d'images correspondantes (pour les pages)

		NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);

		niaDAO.obtenirNombreImages(this, criteres);

	}

	public void obtenirPhotoGalerie(Rafraichissable r)

	{

		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();

		int tailleFiltres = valeursFiltres.length;

		String[][] criteres2 = new String[tailleFiltres + 2][2];

		String[] limite = { "ci_limite", "" + taillePage };

		String[] taillePage = { "ci_numero_page", "" + pageEncours };

		criteres2[0] = limite;

		criteres2[1] = taillePage;

		for (int i = 0; i < valeursFiltres.length; i++) {

			criteres2[i + 2] = valeursFiltres[i];

		}

		// et on crée un DAO auquel on les transmet et qui envoie une requete

		// pour recevoir les images

		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);

		liaDAO.ObtenirListeImages(this, criteres2);

	}

	/**

	 * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et

	 * lancer l'interface appropriée

	 */

	@SuppressWarnings("static-access")

	public void uploaderImages() {

		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);

		IuADaO.choisirMethodeUpload();

	}

	/**

	 * Met à jour la liste des images à partir d'un objet

	 *

	 * @param o

	 *            la nouvelle liste d'image

	 */

	public void rafraichirListeImage(Object o) {

		cacheImage = (ListeImageCarnet) o;

	}

	/**

	 * Met à jour l'arbre des mots clés à partir d'un objet

	 *

	 * @param o

	 *            le nouvel arbre de mots clés

	 */

	public void rafraichirArbreMotsCles(Object o) {

		arbreMotsCles = (com.gwtext.client.data.Tree) o;

	}

	/**

	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet

	 *

	 * @param o

	 *            la nouvelle table des mots clés

	 */

	@SuppressWarnings("unchecked")

	public void rafraichirMotsCles(Object o) {

		if (o instanceof HashMap) {

			motsCles = (HashMap<String, String>) o;

		}

	}

	/**

	 * Va chercher les métadonnées associées à une image dans la liste des

	 * images chargée dans le modèle

	 *

	 * @param r

	 *            le rafraichissable auquel on enverra les informations

	 * @param id

	 *            l'identifiant de l'image

	 */

	public void obtenirMetadonnees(Rafraichissable r, String id) {

		ImageCarnet im = (ImageCarnet) cacheImage.get(id);

		Object meta[] = new Object[3];

		meta[0] = im.getMetadonnesExif();

		meta[1] = im.getMetadonnesIptc();

		meta[2] = im.getInfoGenerales();

		r.rafraichir(meta, false);

	}

	/**

	 * Va chercher les mots clés associés à une image dans la liste des images

	 * chargée dans le modèle

	 *

	 * @param r

	 *            le rafraichissable auquel on enverra les informations

	 * @param id

	 *            l'identifiant de l'image

	 */

	public void obtenirMotsClesId(Rafraichissable r, String id) {

		ImageCarnet im = cacheImage.get(id);

		String motsClesId = im.getMotsCles();

		String[] motsClesIdTab = motsClesId.split(",");

		r.rafraichir(motsClesIdTab, false);

	}

	/**

	 * Met à jour la liste des images en local et appelle le DAO de mise à jour

	 * pour les commentaires et la date des images selectionnées

	 *

	 * @param commentaires

	 *            le commentaire à appliquer

	 * @param date

	 *            la date à appliquer

	 * @param ids

	 *            les identifiants des images selectionnées

	 */

	public void mettreAJourCacheImage(String commentaires, String date,

			String note, String ids[]) {

		for (int i = 0; i < ids.length; i++) {

			String key = ids[i];

			ImageCarnet ic = cacheImage.get(key);

			ic.miseAJourInfoGenerales(commentaires, date, note);

			mettreAjourBaseDeDonneesImageCarnet(ic);

		}

	}

	/**

	 * Ajoute un nouveau mot clés à la liste des mots clés locale

	 *

	 * @param text

	 *            le mot clé

	 * @param id

	 *            l'identifiant du mot clé

	 */

	public void mettreAjourMotsClesId(String text, String id) {

		motsCles.put(id, text);

	}

	/**

	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes

	 * les informations des images modifiées par l'utilisateur

	 */

	public void mettreAJourBaseDeDonneesListeImageCarnet() {

		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);

		liDaO.SynchroniserBaseDeDonnees(cacheImage);

	}

	/**

	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes

	 * les informations d'une image donnée

	 *

	 * @param ic

	 *            l'image à synchroniser avec la base

	 */

	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {

		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);

		iaDaO.SynchroniserBaseDeDonnees(ic);

	}

	/**

	 * Supprime les images données du cache local et appelle le DAO qui les

	 * supprime de la base de données

	 *

	 * @param ids

	 *            les identifiants des images selectionnées

	 */

	public void supprimerImages(String[] ids) {

		String rids[] = new String[ids.length];

		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);

		for (int i = 0; i < ids.length; i++) {

			String key = ids[i];

			ImageCarnet ic = cacheImage.get(key);

			rids[i] = ic.getId();

			cacheImage.remove(key);

		}

		if (rids.length != 0) {

			liDao.supprimerBaseDeDonnees(rids);

		}

	}

	/**

	 * Met à jour les données locales suivant le type des nouvelles données et

	 * appelle le médiateur pour le notifier de la mise à jour

	 */

	public void rafraichir(Object nouvelleDonnees,

			boolean repandreRafraichissement) {

		// si l'on a reçu une liste d'images

		if (nouvelleDonnees instanceof ListeImageCarnet) {

			ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;

			Object[][] photoData = new Object[data.size()][9];

			int i = 0;

			if (data.size() == 0) {

				pageEncours = 0;

			}

			// on la parse et on récupère les informations quiç nous interessent

			for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {

				ImageCarnet im = data.get(it.next());

				photoData[i][0] = im.getOrdre();

				photoData[i][1] = im.getDate();

				photoData[i][2] = im.getIptcCity();

				photoData[i][3] = im.getMake() + " " + im.getModel();

				photoData[i][4] = im.getSUrl();

				photoData[i][5] = im.getMUrl();

				photoData[i][6] = im.getLUrl();

				photoData[i][7] = im.getNote();

				photoData[i][8] = im.getId();

				i++;

			}

			// creation du store qui les contient

			FieldDef defNumImage = new IntegerFieldDef("num_image");

			FieldDef defDatImage = new StringFieldDef("dat_image");

			FieldDef defLieImage = new StringFieldDef("lie_image");

			FieldDef defAppImage = new StringFieldDef("app_image");

			FieldDef defUrlImageS = new StringFieldDef("url_image_S");

			FieldDef defUrlImageM = new StringFieldDef("url_image_M");

			FieldDef defUrlImage = new StringFieldDef("url_image");

			FieldDef defNoteImage = new IntegerFieldDef("note_image");

			FieldDef defIdImage = new IntegerFieldDef("id_image");

			FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,

					defAppImage, defUrlImageS, defUrlImageM, defUrlImage,

					defNoteImage, defIdImage };

			RecordDef rd = new RecordDef(defTab);

			final MemoryProxy dataProxy = new MemoryProxy(photoData);

			final ArrayReader reader = new ArrayReader(rd);

			final Store photoStore = new Store(dataProxy, reader);

			rafraichirListeImage(nouvelleDonnees);

			st = photoStore;

			st.load();

			// par défaut le store est trié sur le numéro d'image

			st.sort("num_image");

			// si on doit répandre les données, on notifie le médiateur qui les

			// distribuera à son tour

			if (repandreRafraichissement) {

				getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);

			}

		}

		// si on reçoit un tableau JSON

		if (nouvelleDonnees instanceof JSONArray) {

			// alors on a reçu les informations sur les mots clés

			JSONArray reponse = (JSONArray) nouvelleDonnees;

			final int taillemax = reponse.size();

			// si le tableau est vide

			if (taillemax == 0) {

				// on crée un arbre vide

				TreeNode root = new TreeNode();

				root.setId("racine");

				root.setText("Tags");

				String[] usObj = { "Tags", "racine" };

				root.setUserObject(usObj);

				arbreMotsCles.setRootNode(root);

			}

			// pour chacun des élements du tableau

			for (int j = 0; j < taillemax; j++) {

				// on extrait les élements du tableau

				if (reponse.get(j).isObject() != null) {

					JSONObject noeud = (JSONObject) reponse.get(j);

					String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur")

							.isString().stringValue();

					String mot_cle = noeud.get("cmc_mot_cle").isString()

							.stringValue();

					String parent = noeud.get("cmc_id_parent").isString()

							.stringValue();

					String[] usObj = { mot_cle, id_noeud };

					// et on construit l'arbre à partir de la racine (qui est

					// toujoursl e premier élément)

					if (id_noeud.equals("racine")) {

						TreeNode root = new TreeNode();

						root.setId(id_noeud);

						root.setText(mot_cle);

						root.setUserObject(usObj);

						arbreMotsCles.setRootNode(root);

					} else {

						// et en ajoutant les noeuds un à un (qui sont renvoyé

						// dans l'ordre hierarchique de leur niveau

						// ce qui permet de les traiter séquentiellement)

						TreeNode node = new TreeNode();

						node.setId(id_noeud);

						node.setText(mot_cle);

						node.setChecked(false);

						Node parentNode = arbreMotsCles.getNodeById(parent);

						node.setUserObject(usObj);

						parentNode.appendChild(node);

					}

				}

			}

			// enfin on met à jour l'arbre des mots clés contenu dans le modèle

			rafraichirArbreMotsCles(arbreMotsCles);

			// et on notifie le médiateur de la mise à jour en lui passant une

			// copie des données

			getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);

		}

		// Si on reçoit un tableau d'entiers

		// c'est un tableau d'un seul entier qui est le nombre d'images

		// correspondant aux critères

		if (nouvelleDonnees instanceof int[]) {

			int[] pages = (int[]) nouvelleDonnees;

			// on calcule le nombre de pages nécessaires et on les met à jour

			// dans le modèle

			pageMax = calculerNbPages(pages[0]);

			nbElements = pages[0];

			// et on notifie de le mediateur du changement des valeurs

			getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,

					taillePage, pages[0]);

			obtenirPhotoGalerie(this) ;

		}

		if(nouvelleDonnees instanceof ListeObservation) {

			getIMediateur().rafraichirMiniListeObservations(nouvelleDonnees) ;

		}

	}

	/**

	 * Affiche les paires / valeur de tous les mots clés stockés

	 */

	public void afficherMotsCles() {

		for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {

			String key = it.next();

			String valeur = (String) motsCles.get(key);

			System.out.println("clé : " + key + " valeur : " + valeur);

		}

	}

	/**

	 * Met à jour les mots clés associés à une image et appelle le DAO pour

	 * synchroniser la base de données

	 *

	 * @param ids

	 *            les identifiants des images selectionnées

	 * @param motsClesEnCours

	 *            les mots clés à appliquer aux images

	 * @param arbreMC

	 *            l'arbre de mots clés en cours

	 */

	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,

			com.gwtext.client.data.Tree arbreMC) {

		for (int i = 0; i < ids.length; i++) {

			if (cacheImage.containsKey(ids[i])) {

				ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);

				ic.mettreAjourMotsCles(motsClesEnCours);

				ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this);

				imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic);

			}

		}

		rafraichirArbreMotsCles(arbreMC);

	}

	/**

	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la

	 * base de données

	 */

	public void initialiserArbreMotsCles() {

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

		MCDao.obtenirListeMotsCles(this);

	}

	/**

	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable

	 * donné, qui le demande

	 *

	 * @param r

	 *            le rafraichissable demandeur de l'arbre

	 */

	public void obtenirArbreMotCle(Rafraichissable r) {

		r.rafraichir(arbreMotsCles, false);

	}

	/**

	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui

	 * fait la mise à jour de l'arbre des mots clés dans la base

	 *

	 * @param n

	 *            le nouveau noeud contenant le mot clé

	 * @param arbreMC

	 *            l'arbre des mots cles en cours

	 */

	public void ajouterMotCleDansArbre(TreeNode n,

			com.gwtext.client.data.Tree arbreMC) {

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

		String[] usObj = (String[]) n.getUserObject();

		String motCle = usObj[0];

		String id = usObj[1];

		String parentId = "";

		if (!id.equals("racine")) {

			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();

			parentId = parentUsObj[1];

		} else {

			parentId = "racine";

		}

		rafraichirArbreMotsCles(arbreMC);

		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="

				+ motCle + "&id=" + id + "&parent=" + parentId;

		MCDao.ajouterBaseDeDonnees(nouveauMotCle);

	}

	/**

	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va

	 * supprimer les mots clés associés dans la base

	 *

	 * @param n

	 *            le noeud à supprimer

	 * @param arbreMC

	 *            l'arbre des mots clés en cours

	 */

	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

		String[] usObj = (String[]) n.getUserObject();

		String id = usObj[1];

		MCDao.supprimerBaseDeDonnees(id);

	}

	/**

	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le

	 * DAO qui synchronise la modification dans la base de données

	 *

	 * @param n

	 *            le noeud modifié

	 * @param arbreMC

	 *            l'arbre des mots clés en cours

	 */

	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

		String[] usObj = (String[]) n.getUserObject();

		String motCle = usObj[0];

		String id = usObj[1];

		String parentId = "";

		if (!id.equals("racine")) {

			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();

			parentId = parentUsObj[1];

		} else {

			parentId = "racine";

		}

		rafraichirArbreMotsCles(arbreMC);

		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="

				+ parentId;

		MCDao.modifierBaseDeDonnees(motCleModifie);

	}

	/**

	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui

	 * reorganise l'arbre dans la base de donnees suivant le changement

	 *

	 * @param n

	 *            le noeud deplace (et son sous arbre associe)

	 * @param arbreMC

	 *            l'arbre des mots cles en cours

	 */

	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this);

		String[] usObj = (String[]) n.getUserObject();

		String motCle = usObj[0];

		String id = usObj[1];

		String parentId = "";

		if (!id.equals("racine")) {

			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();

			parentId = parentUsObj[1];

		} else {

			parentId = "racine";

		}

		rafraichirArbreMotsCles(arbreMC);

		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="

				+ parentId;

		MCDao.deplacerBaseDeDonnees(motCleModifie);

	}

	/**

	 * Change le numéro de la page en cours et envoie une demande de mise à jour

	 * des données

	 *

	 * @param nouvellePageCourante

	 *            la nouvelle page à afficher

	 */

	public void changerNumeroPage(int nouvellePageCourante) {

		pageEncours = nouvellePageCourante;

		obtenirNombrePhotoGalerie(this);

	}

	/**

	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements

	 * donnés en fonction de la taille de page en cours

	 *

	 * @param nbElements

	 *            le nombre d'élements total

	 * @return le nombre de pages

	 */

	public int calculerNbPages(int nbElements) {

		// A cause de la betise de java pour les conversion implicite on fait

		// quelques conversions manuellement

		// pour eviter qu'il arrondisse mal la division

		// nombre de pages = (nombre d'element / taille de la page) arrondie à

		// l'entier superieur

		double nPage = (1.0 * nbElements) / (1.0 * taillePage);

		double nPageRound = Math.ceil(nPage);

		Double nPageInt = new Double(nPageRound);

		// on convertit en entier

		return nPageInt.intValue();

	}

	/**

	 * Recalcule la page en cours lors du changement du nombre d'élements

	 *

	 * @param nbElements

	 *            le nombre d'élements total

	 * @return la nouvelle page encours

	 */

	public int calculerPageCourante(int nbElements) {

		// on calcule le nombre de page

		int nouvelNbPages = calculerNbPages(nbElements);

		// la nouvelle page en cours

		double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)

				* (1.0 * nouvelNbPages);

		// on arrondit au supérieur

		double nPageRound = Math.ceil(nPageCourante);

		Double nPageInt = new Double(nPageRound);

		// on convertit en entier

		return Math.abs(nPageInt.intValue());

	}

	/**

	 * Change la taille de page et recalcule la page encours

	 *

	 * @param nouvelleTaillePage

	 *            la nouvelle taille de page à utiliser

	 */

	public void changerTaillePage(int nouvelleTaillePage) {

		taillePage = nouvelleTaillePage;

		pageEncours = calculerPageCourante(nbElements);

		obtenirNombrePhotoGalerie(this);

	}

	/**

	 * Notifie le mediateur que l'upload ou le download est termine et qu'il

	 * faut rafraichir les vues avec les nouvelles données

	 */

	public void requeteTerminee() {

		getIMediateur().demasquerChargement();

		getIMediateur().rafraichirToutesVues();

	}

	/**

	 * Obtient l'identifiant de l'utilisateur auprès du médiateur

	 *

	 * @return id de l'utilisateur

	 */

	public String getIdentifiant() {

		return getIMediateur().getIdentifiant();

	}

	/**

	 * renvoie la taille d'une image grâce à son identifiant

	 *

	 * @param id

	 *            l'identifiant de l'image

	 * @return un tableau contenant la longueur et la hauteur de l'image

	 */

	public String[] obtenirTailleImage(String id) {

		return (cacheImage.get(id)).getTailleImage();

	}

	/**

	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il

	 * renvoie la note associée au rafrachissable qui la demande

	 *

	 * @param r

	 *            le rafraichissable demandeur de l'information

	 * @param id

	 *            l'identifiant del'image

	 */

	public void obtenirNote(Rafraichissable r, String id) {

		r.rafraichir((cacheImage.get(id)).getNote(), true);

	}

	/**

	 * Accesseur pour la configuration en cours d'utilisation

	 *

	 * @return la configuration

	 */

	public Configuration getConfig() {

		return config;

	}

	/**

	 * Ajoute des images à la selection en cours

	 *

	 * @param ids

	 *            les identifiants des images à ajouter

	 */

	public void ajouterImagesSelection(String[] ids) {

		for (int i = 0; i < ids.length; i++) {

			selectionImages.add(ids[i]);

		}

	}

	/**

	 * Vide la selection en cours

	 */

	public void viderSelection() {

		selectionImages.clear();

	}

	public String renvoyerSelection() {

		String selection = "";

		if(selectionImages.size() <= 0)

		{

			selection += "-255" ;

		}

		else

		{

			for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {

				String idEncours = it.next();

				selection += idEncours + ",";

			}

		}

		return selection;

	}

	public void lierImagesObervations(String idsObs, String idsImg) {

		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;

		lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;

	}

	public void obtenirLiaisonObservations(ImageMediateur imageMediateur,

			String id) {

		String imgId = cacheImage.get(id).getId() ;

		LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;

		lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;

	}

	public void supprimerLiaisonImages(String idImg, String idObs) {

		idImg = cacheImage.get(idImg).getId() ;

		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;

		lienDAO.supprimerLienImageObservation(idImg, idObs) ;

	}

}