WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/image/ImageModele.java


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.dao.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.user.client.Window;
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.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;
	}
	
 
 
 
 
 
 
	public String[][] obtenirFiltresPourComptage() {
 
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
 
		int tailleFiltres = valeursFiltres.length;
 
		String[][] criteres = new String[tailleFiltres][2];
 
		String[] utilisateur = {
				"" + getIMediateur().getIdentifiant() };
		criteres[0] = utilisateur;
 
 
		for (int i = 0; i < valeursFiltres.length; i++) {
			criteres[i] = valeursFiltres[i];
		}
		
		return criteres;
	}
	
	public String[][] obtenirFiltresPourDonnees() {
 
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
		
		int tailleFiltres = valeursFiltres.length;
		
		String[][] criteres2 = new String[tailleFiltres + 2][2];
		
		String[] limite = { "limite", "" + taillePage };
		String[] taillePage = { "numero_page", "" + pageEncours };
		
		criteres2[0] = limite;
		criteres2[1] = taillePage;
 
		for (int i = 0; i < valeursFiltres.length; i++) {
			criteres2[i + 2] = valeursFiltres[i];
		}
		
		return valeursFiltres;
	}
 
	/**
	 * 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[][] criteres = obtenirFiltresPourComptage();
 
		// 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 + 4][2];
		
		String[] tri = { "tri", "" + getIMediateur().getTri() };
		String[] triDir = { "dir", "" + getIMediateur().getDirectionTri()};
		
		String[] limite = { "limite", "" + taillePage };
		String[] taillePage = { "numero_page", "" + pageEncours };
		
		criteres2[0] = limite;
		criteres2[1] = taillePage;
		
		criteres2[2] = tri;
		criteres2[3] = triDir;
 
		for (int i = 0; i < valeursFiltres.length; i++) {
			criteres2[i + 4] = 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(boolean multiple) {
		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
		if(multiple) {
			IuADaO.appelerUploadMultiple();
		}
		else 
		{
			IuADaO.appelerUploadSimple();
		}
	}
 
	/**
	 * 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 = 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) {
 
		String[] motsClesIdTab = getMotsClesId(id);
		r.rafraichir(motsClesIdTab, false);
	}
	
	public String[] getMotsClesId(String idImage) {
		ImageCarnet im = cacheImage.get(idImage);
		String motsClesId = im.getMotsCles();
		String[] motsClesIdTab = motsClesId.split(",");
		
		return motsClesIdTab;
	}
	
	/**
	 * Va chercher le nom du mot clé associé à un id dans le cache local
	 * 
	 * @param String id
	 *            id du mot clé
	 * @return le mot clé associé à l'identifiant
	 */
	public String obtenirTexteMotCle(String id) {
		
		String correspondanceId = "";
		
		String motCleTexte = motsCles.get(id);
		
		if(motCleTexte != null) {
			correspondanceId = motCleTexte;
		}
		
		return correspondanceId;
	}
	
	/**
	 * Construit une chaine contenant le texte des mots clés séparés par des virgules
	*/
	public String renvoyerChaineMotClesTexte(ImageCarnet ic) {
		String chaineMotsCles = ic.getMotsCles();
		String[] tabMotsCles = chaineMotsCles.split(",");
		String chaineMotsClesTexte = "";
		for (int i = 0; i < tabMotsCles.length; i++) {
			chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);
			chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";
		}
		return chaineMotsClesTexte;
	}
 
	/**
	 * 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
	 */
	@Override
	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()][14];
			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.getNomOriginal();
				photoData[i][2] = im.getDate();
				photoData[i][3] = im.getIptcCity();
				photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();
				photoData[i][5] = im.getUrlFormatListe();
				photoData[i][6] = im.getUrlFormatGalerie();
				photoData[i][7] = im.getUrlFormatZoom();
				photoData[i][8] = im.getNote();
				photoData[i][9] = im.getId();
				photoData[i][10] = im.getTailleImage()[1];
				photoData[i][11] = im.getTailleImage()[0];
				photoData[i][12] = im.getIdsObsAssociees();
				photoData[i][13] = im.getIdsObsAssociees();
 
				i++;
			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
			RecordDef rd = new RecordDef(ImageMediateur.getDefinitionsChampsGrilleImages());
 
			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();
 
 
 
 
			// 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 donneesArbre = (JSONArray)nouvelleDonnees;
			
			Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Tags", "racine", donneesArbre, false);
			
			arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
			motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
 
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
			rafraichirArbreMotsCles(arbreMotsCles);
			// la table de hachage
			rafraichirMotsCles(motsCles);
			// 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((ListeObservation)nouvelleDonnees) ;
		}
		
		if(nouvelleDonnees instanceof Tree) {
			rafraichirArbreMotsCles(nouvelleDonnees);
			getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees);
		}
	}
 
	/**
	 * 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) {
		
		String idImgs = ""; 
		for (int i = 0; i < ids.length; i++) {
			String idImageEnCours = "";
			if (cacheImage.containsKey(ids[i])) {
				ImageCarnet ic = cacheImage.get(ids[i]);
				idImageEnCours = ic.getId();
				ic.mettreAjourMotsCles(motsClesEnCours);
			}
			idImgs += idImageEnCours;
			idImgs += (i < (ids.length - 1)) ? ",": ""; 
		}
		
		LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this);
		liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours);
 
		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("images");
			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, Rafraichissable r) {
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
		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();
			if(!parentUsObj[1].equals("racine")) {
				parentId = parentUsObj[1];
			}
		}
 
		rafraichirArbreMotsCles(arbreMC);
		mettreAjourMotsClesId(motCle, id);
 
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
				+ motCle + "&id=" + id + "&parent=" + parentId;
		MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
	}
 
	/**
	 * 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, Rafraichissable r) {
 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
		String[] usObj = (String[]) n.getUserObject();
		String id = usObj[1];
 
		MCDao.supprimerBaseDeDonnees(id, r);
 
	}
 
	/**
	 * 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, Rafraichissable r) {
 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
		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();
			if(!parentUsObj[1].equals("racine")) {
				parentId = parentUsObj[1];
			}
		}
 
		rafraichirArbreMotsCles(arbreMC);
 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
				+ parentId;
		MCDao.modifierBaseDeDonnees(motCleModifie, r);
 
	}
 
	/**
	 * 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, Rafraichissable r) {
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
		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();
			if(!parentUsObj[1].equals("racine")) {
				parentId = parentUsObj[1];
			}
		}
 
		rafraichirArbreMotsCles(arbreMC);
 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
				+ parentId;
		MCDao.deplacerBaseDeDonnees(motCleModifie, r);
	}
 
	/**
	 * 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);
	}
	
	/**
	 * Met la valeur de la page en cours à la dernière 
	 */
	public void setDernierePage() {
		changerNumeroPage(pageMax);
	}
 
	/**
	 * 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++) {
			
			String idImg = cacheImage.get(ids[i]).getId();
			selectionImages.add(idImg);
		}
	}
 
	public int getCompteSelection() {
		return selectionImages.size();
	}
	
	/**
	 * 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[] idsImg, String idObs) {
		
		String chaineIdImg = "";
		
		for(int i = 0; i < idsImg.length; i++) {
			String idImg = cacheImage.get(idsImg[i]).getId() ;
			chaineIdImg += ","+idImg;
		}
		
		chaineIdImg = chaineIdImg.replaceFirst(",", "");
		
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
		lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ;		
	}
 
	public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) {
		
		String[] tri = { "tri", "" + getIMediateur().getTriMiniListeObs() };
		String[] triDir = { "tri_dir", "" + getIMediateur().getDirectionTriMiniListeObs()};
		
		String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}, tri, triDir} ;		
		
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
		ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
		loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres);	
		
	}
 
	public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) {
		
		String[][] criteres = {{critere[0],critere[1]}} ;		
		
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
		NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this);
		noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres);	
		
	}
 
	public void obtenirDatesImages(Rafraichissable r) {
		ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this);
		lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant());
	}
	
	public String obtenirIdPourOrdre(String ordreImage) {
		return cacheImage.get(ordreImage).getId();
	}
 
}

Rev 2618	Rev 2726
1	`package org.tela_botanica.client.image;`	1	`package org.tela_botanica.client.image;`
2		2
3	`import java.util.HashMap;`	3	`import java.util.HashMap;`
4	`import java.util.Iterator;`	4	`import java.util.Iterator;`
5	`import java.util.Vector;`	5	`import java.util.Vector;`
6		6
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	7	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;`	8	`import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;`
9	`import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;`	9	`import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;`
10	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;`	10	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;`
11	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`	11	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`
12	`import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;`	12	`import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;`
13	`import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;`	13	`import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;`
14	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`	14	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`
15	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`	15	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`
16	`import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;`	16	`import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;`
17	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`	17	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`
18	`import org.tela_botanica.client.modeles.objets.Configuration;`	18	`import org.tela_botanica.client.modeles.objets.Configuration;`
19	`import org.tela_botanica.client.modeles.objets.ImageCarnet;`	19	`import org.tela_botanica.client.modeles.objets.ImageCarnet;`
20	`import org.tela_botanica.client.modeles.objets.ListeImageCarnet;`	20	`import org.tela_botanica.client.modeles.objets.ListeImageCarnet;`
21	`import org.tela_botanica.client.modeles.objets.ListeObservation;`	21	`import org.tela_botanica.client.modeles.objets.ListeObservation;`
22	`import org.tela_botanica.client.modeles.objets.Utilisateur;`	22	`import org.tela_botanica.client.modeles.objets.Utilisateur;`
23	`import org.tela_botanica.client.util.MotsClesUtilitaire;`	23	`import org.tela_botanica.client.util.MotsClesUtilitaire;`
24		24
25	`import com.google.gwt.json.client.JSONArray;`	25	`import com.google.gwt.json.client.JSONArray;`
26	`import com.google.gwt.user.client.Window;`	26	`import com.google.gwt.user.client.Window;`
27	`import com.gwtext.client.data.ArrayReader;`	27	`import com.gwtext.client.data.ArrayReader;`
28	`import com.gwtext.client.data.FieldDef;`	28	`import com.gwtext.client.data.FieldDef;`
29	`import com.gwtext.client.data.IntegerFieldDef;`	29	`import com.gwtext.client.data.IntegerFieldDef;`
30	`import com.gwtext.client.data.MemoryProxy;`	30	`import com.gwtext.client.data.MemoryProxy;`
31	`import com.gwtext.client.data.RecordDef;`	31	`import com.gwtext.client.data.RecordDef;`
32	`import com.gwtext.client.data.Store;`	32	`import com.gwtext.client.data.Store;`
33	`import com.gwtext.client.data.StringFieldDef;`	33	`import com.gwtext.client.data.StringFieldDef;`
34	`import com.gwtext.client.data.Tree;`	34	`import com.gwtext.client.data.Tree;`
35	`import com.gwtext.client.widgets.tree.TreeNode;`	35	`import com.gwtext.client.widgets.tree.TreeNode;`
36		36
37	`/**`	37	`/**`
38	`* Modèle d'accès aux données pour les images. C'est un singleton`	38	`* Modèle d'accès aux données pour les images. C'est un singleton`
39	`*`	39	`*`
40	`* @author aurelien`	40	`* @author aurelien`
41	`*`	41	`*`
42	`*/`	42	`*/`
43	`public class ImageModele implements Rafraichissable {`	43	`public class ImageModele implements Rafraichissable {`
44		44
45	`/**`	45	`/**`
46	`* Booleen indiquant si le médiateur est instancié (l'instance doit être`	46	`* Booleen indiquant si le médiateur est instancié (l'instance doit être`
47	`* unique donc le booleen est static)`	47	`* unique donc le booleen est static)`
48	`*/`	48	`*/`
49	`private static boolean estInstancie = false;`	49	`private static boolean estInstancie = false;`
50		50
51	`/**`	51	`/**`
52	`* le modèle lui même`	52	`* le modèle lui même`
53	`*/`	53	`*/`
54	`private static ImageModele thisModele = null;`	54	`private static ImageModele thisModele = null;`
55		55
56	`/**`	56	`/**`
57	`* Le médiateur associé au modèle`	57	`* Le médiateur associé au modèle`
58	`*/`	58	`*/`
59	`private ImageMediateur iMediateur = null;`	59	`private ImageMediateur iMediateur = null;`
60		60
61	`/**`	61	`/**`
62	`* La configuration en cours`	62	`* La configuration en cours`
63	`*/`	63	`*/`
64	`private Configuration config = null;`	64	`private Configuration config = null;`
65		65
66	`/**`	66	`/**`
67	`* La liste des image affichées en cours`	67	`* La liste des image affichées en cours`
68	`*/`	68	`*/`
69	`private ListeImageCarnet cacheImage = new ListeImageCarnet(0);`	69	`private ListeImageCarnet cacheImage = new ListeImageCarnet(0);`
70	`/**`	70	`/**`
71	`* Table de correspondance entre les mots clés et leurs identifiants`	71	`* Table de correspondance entre les mots clés et leurs identifiants`
72	`*/`	72	`*/`
73	`private HashMap<String, String> motsCles = new HashMap<String, String>(0);`	73	`private HashMap<String, String> motsCles = new HashMap<String, String>(0);`
74	`/**`	74	`/**`
75	`* Le store contenant les données à afficher, que le modèle transmet au`	75	`* Le store contenant les données à afficher, que le modèle transmet au`
76	`* médiateur quand il le demande`	76	`* médiateur quand il le demande`
77	`*/`	77	`*/`
78	`private Store st = null;`	78	`private Store st = null;`
79	`/**`	79	`/**`
80	`* Arbre des mots clés`	80	`* Arbre des mots clés`
81	`*/`	81	`*/`
82	`private com.gwtext.client.data.Tree arbreMotsCles = new Tree();`	82	`private com.gwtext.client.data.Tree arbreMotsCles = new Tree();`
83		83
84	`/**`	84	`/**`
85	`* Numéro de page en cours`	85	`* Numéro de page en cours`
86	`*/`	86	`*/`
87	`private int pageEncours = 0;`	87	`private int pageEncours = 0;`
88	`/**`	88	`/**`
89	`* Nombre de pages totales`	89	`* Nombre de pages totales`
90	`*/`	90	`*/`
91	`private int pageMax = 1;`	91	`private int pageMax = 1;`
92	`/**`	92	`/**`
93	`* Taille de page (par défaut 50)`	93	`* Taille de page (par défaut 50)`
94	`*/`	94	`*/`
95	`private int taillePage = 50;`	95	`private int taillePage = 50;`
96	`/**`	96	`/**`
97	`* Nombre d'éléments total correspondant à la requete`	97	`* Nombre d'éléments total correspondant à la requete`
98	`*/`	98	`*/`
99	`private int nbElements = 0;`	99	`private int nbElements = 0;`
100		100
101	`/**`	101	`/**`
102	`* "Presse papier" pour les images qui permet de garder en mémoire une`	102	`* "Presse papier" pour les images qui permet de garder en mémoire une`
103	`* sélection`	103	`* sélection`
104	`*/`	104	`*/`
105	`private Vector<String> selectionImages = new Vector<String>(0);`	105	`private Vector<String> selectionImages = new Vector<String>(0);`
106		106
107	`/**`	107	`/**`
108	`* Retourne une instance de manière unique`	108	`* Retourne une instance de manière unique`
109	`*`	109	`*`
110	`* @param im`	110	`* @param im`
111	`* le médiateur à associer`	111	`* le médiateur à associer`
112	`* @return l'instance du modèle`	112	`* @return l'instance du modèle`
113	`*/`	113	`*/`
114	`static ImageModele Instance(ImageMediateur im) {`	114	`static ImageModele Instance(ImageMediateur im) {`
115	`// si le modèle n'est pas encore instancié`	115	`// si le modèle n'est pas encore instancié`
116	`if (!estInstancie) {`	116	`if (!estInstancie) {`
117	`// on en crée un nouveau`	117	`// on en crée un nouveau`
118	`estInstancie = true;`	118	`estInstancie = true;`
119	`thisModele = new ImageModele(im);`	119	`thisModele = new ImageModele(im);`
120	`}`	120	`}`
121		121
122	`// sinon on retourne le "pointeur" vers le modèle lui-même`	122	`// sinon on retourne le "pointeur" vers le modèle lui-même`
123	`return thisModele;`	123	`return thisModele;`
124		124
125	`}`	125	`}`
126		126
127	`/**`	127	`/**`
128	`* Le constructeur est privé et seule la méthode instance y accède`	128	`* Le constructeur est privé et seule la méthode instance y accède`
129	`*`	129	`*`
130	`* @param im`	130	`* @param im`
131	`* le médiateur à associer`	131	`* le médiateur à associer`
132	`*/`	132	`*/`
133	`private ImageModele(ImageMediateur im) {`	133	`private ImageModele(ImageMediateur im) {`
134		134
135	`iMediateur = im;`	135	`iMediateur = im;`
136	`config = new Configuration();`	136	`config = new Configuration();`
137	`}`	137	`}`
138		138
139	`/**`	139	`/**`
140	`* Accesseur pour le médiateur`	140	`* Accesseur pour le médiateur`
141	`*`	141	`*`
142	`* @return le médiateur associé`	142	`* @return le médiateur associé`
143	`*/`	143	`*/`
144	`public ImageMediateur getIMediateur() {`	144	`public ImageMediateur getIMediateur() {`
145	`return iMediateur;`	145	`return iMediateur;`
146	`}`	146	`}`
147		147
148	`/**`	-
149	`* Appelle le DAO asynchrone pour obtenir la liste des images`	-
150	`*`	-
151	`* @param r`	-
152	`* le rafraichissable auxquel on enverra les données`	-
153	`*/`	-
154	`public void obtenirNombrePhotoGalerie(Rafraichissable r) {`	148	`public String[][] obtenirFiltresPourComptage() {`
155		149
156	`String valeursFiltres[][] = getIMediateur().renvoyerFiltres();`	150	`String valeursFiltres[][] = getIMediateur().renvoyerFiltres();`
157		151
158	`int tailleFiltres = valeursFiltres.length;`	152	`int tailleFiltres = valeursFiltres.length;`
159		153
160	`String[][] criteres = new String[tailleFiltres][2];`	154	`String[][] criteres = new String[tailleFiltres][2];`
161		155
162	`String[] utilisateur = {`	156	`String[] utilisateur = {`
163	`"" + getIMediateur().getIdentifiant() };`	157	`"" + getIMediateur().getIdentifiant() };`
164	`criteres[0] = utilisateur;`	158	`criteres[0] = utilisateur;`
165		159
166		160
167	`for (int i = 0; i < valeursFiltres.length; i++) {`	161	`for (int i = 0; i < valeursFiltres.length; i++) {`
168	`criteres[i] = valeursFiltres[i];`	162	`criteres[i] = valeursFiltres[i];`
169	`}`	163	`}`
-		164
-		165	`return criteres;`
-		166	`}`
-		167
-		168	`public String[][] obtenirFiltresPourDonnees() {`
-		169
-		170	`String valeursFiltres[][] = getIMediateur().renvoyerFiltres();`
-		171
-		172	`int tailleFiltres = valeursFiltres.length;`
-		173
-		174	`String[][] criteres2 = new String[tailleFiltres + 2][2];`
-		175
-		176	`String[] limite = { "limite", "" + taillePage };`
-		177	`String[] taillePage = { "numero_page", "" + pageEncours };`
-		178
-		179	`criteres2[0] = limite;`
-		180	`criteres2[1] = taillePage;`
-		181
-		182	`for (int i = 0; i < valeursFiltres.length; i++) {`
-		183	`criteres2[i + 2] = valeursFiltres[i];`
-		184	`}`
-		185
-		186	`return valeursFiltres;`
-		187	`}`
-		188
-		189	`/**`
-		190	`* Appelle le DAO asynchrone pour obtenir la liste des images`
-		191	`*`
-		192	`* @param r`
-		193	`* le rafraichissable auxquel on enverra les données`
-		194	`*/`
-		195	`public void obtenirNombrePhotoGalerie(Rafraichissable r) {`
-		196
-		197	`String[][] criteres = obtenirFiltresPourComptage();`
170		198
171	`// on les crée un DAO auquel on les transmet et qui demande le nombre`	199	`// on les crée un DAO auquel on les transmet et qui demande le nombre`
172	`// d'images correspondantes (pour les pages)`	200	`// d'images correspondantes (pour les pages)`
173	`NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);`	201	`NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);`
174	`niaDAO.obtenirNombreImages(this, criteres);`	202	`niaDAO.obtenirNombreImages(this, criteres);`
175	`}`	203	`}`
176		204
177	`public void obtenirPhotoGalerie(Rafraichissable r)`	205	`public void obtenirPhotoGalerie(Rafraichissable r)`
178	`{`	206	`{`
179	`String valeursFiltres[][] = getIMediateur().renvoyerFiltres();`	207	`String valeursFiltres[][] = getIMediateur().renvoyerFiltres();`
180		208
181	`int tailleFiltres = valeursFiltres.length;`	209	`int tailleFiltres = valeursFiltres.length;`
182		210
-		211	`String[][] criteres2 = new String[tailleFiltres + 4][2];`
-		212
-		213	`String[] tri = { "tri", "" + getIMediateur().getTri() };`
183	`String[][] criteres2 = new String[tailleFiltres + 2][2];`	214	`String[] triDir = { "dir", "" + getIMediateur().getDirectionTri()};`
184		215
185	`String[] limite = { "limite", "" + taillePage };`	216	`String[] limite = { "limite", "" + taillePage };`
186	`String[] taillePage = { "numero_page", "" + pageEncours };`	217	`String[] taillePage = { "numero_page", "" + pageEncours };`
187		218
188	`criteres2[0] = limite;`	219	`criteres2[0] = limite;`
189	`criteres2[1] = taillePage;`	220	`criteres2[1] = taillePage;`
-		221
-		222	`criteres2[2] = tri;`
-		223	`criteres2[3] = triDir;`
190		224
191	`for (int i = 0; i < valeursFiltres.length; i++) {`	225	`for (int i = 0; i < valeursFiltres.length; i++) {`
192	`criteres2[i + 2] = valeursFiltres[i];`	226	`criteres2[i + 4] = valeursFiltres[i];`
193	`}`	227	`}`
194		228
195	`// et on crée un DAO auquel on les transmet et qui envoie une requete`	229	`// et on crée un DAO auquel on les transmet et qui envoie une requete`
196	`// pour recevoir les images`	230	`// pour recevoir les images`
197	`ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);`	231	`ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);`
198	`liaDAO.ObtenirListeImages(this, criteres2);`	232	`liaDAO.ObtenirListeImages(this, criteres2);`
199	`}`	233	`}`
200		234
201	`/**`	235	`/**`
202	`* Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et`	236	`* Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et`
203	`* lancer l'interface appropriée`	237	`* lancer l'interface appropriée`
204	`*/`	238	`*/`
205	`@SuppressWarnings("static-access")`	239	`@SuppressWarnings("static-access")`
206	`public void uploaderImages(boolean multiple) {`	240	`public void uploaderImages(boolean multiple) {`
207	`ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);`	241	`ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);`
208	`if(multiple) {`	242	`if(multiple) {`
209	`IuADaO.appelerUploadMultiple();`	243	`IuADaO.appelerUploadMultiple();`
210	`}`	244	`}`
211	`else`	245	`else`
212	`{`	246	`{`
213	`IuADaO.appelerUploadSimple();`	247	`IuADaO.appelerUploadSimple();`
214	`}`	248	`}`
215	`}`	249	`}`
216		250
217	`/**`	251	`/**`
218	`* Met à jour la liste des images à partir d'un objet`	252	`* Met à jour la liste des images à partir d'un objet`
219	`*`	253	`*`
220	`* @param o`	254	`* @param o`
221	`* la nouvelle liste d'image`	255	`* la nouvelle liste d'image`
222	`*/`	256	`*/`
223	`public void rafraichirListeImage(Object o) {`	257	`public void rafraichirListeImage(Object o) {`
224	`cacheImage = (ListeImageCarnet) o;`	258	`cacheImage = (ListeImageCarnet) o;`
225	`}`	259	`}`
226		260
227	`/**`	261	`/**`
228	`* Met à jour l'arbre des mots clés à partir d'un objet`	262	`* Met à jour l'arbre des mots clés à partir d'un objet`
229	`*`	263	`*`
230	`* @param o`	264	`* @param o`
231	`* le nouvel arbre de mots clés`	265	`* le nouvel arbre de mots clés`
232	`*/`	266	`*/`
233	`public void rafraichirArbreMotsCles(Object o) {`	267	`public void rafraichirArbreMotsCles(Object o) {`
234	`arbreMotsCles = (com.gwtext.client.data.Tree) o;`	268	`arbreMotsCles = (com.gwtext.client.data.Tree) o;`
235	`}`	269	`}`
236		270
237	`/**`	271	`/**`
238	`* Met à jour la table de correspondance mots clés / ids à partir d'un objet`	272	`* Met à jour la table de correspondance mots clés / ids à partir d'un objet`
239	`*`	273	`*`
240	`* @param o`	274	`* @param o`
241	`* la nouvelle table des mots clés`	275	`* la nouvelle table des mots clés`
242	`*/`	276	`*/`
243	`@SuppressWarnings("unchecked")`	277	`@SuppressWarnings("unchecked")`
244	`public void rafraichirMotsCles(Object o) {`	278	`public void rafraichirMotsCles(Object o) {`
245	`if (o instanceof HashMap) {`	279	`if (o instanceof HashMap) {`
246	`motsCles = (HashMap<String, String>) o;`	280	`motsCles = (HashMap<String, String>) o;`
247	`}`	281	`}`
248	`}`	282	`}`
249		283
250	`/**`	284	`/**`
251	`* Va chercher les métadonnées associées à une image dans la liste des`	285	`* Va chercher les métadonnées associées à une image dans la liste des`
252	`* images chargée dans le modèle`	286	`* images chargée dans le modèle`
253	`*`	287	`*`
254	`* @param r`	288	`* @param r`
255	`* le rafraichissable auquel on enverra les informations`	289	`* le rafraichissable auquel on enverra les informations`
256	`* @param id`	290	`* @param id`
257	`* l'identifiant de l'image`	291	`* l'identifiant de l'image`
258	`*/`	292	`*/`
259	`public void obtenirMetadonnees(Rafraichissable r, String id) {`	293	`public void obtenirMetadonnees(Rafraichissable r, String id) {`
260	`ImageCarnet im = cacheImage.get(id);`	294	`ImageCarnet im = cacheImage.get(id);`
261		295
262	`Object meta[] = new Object[3];`	296	`Object meta[] = new Object[3];`
263	`meta[0] = im.getMetadonnesExif();`	297	`meta[0] = im.getMetadonnesExif();`
264	`meta[1] = im.getMetadonnesIptc();`	298	`meta[1] = im.getMetadonnesIptc();`
265	`meta[2] = im.getInfoGenerales();`	299	`meta[2] = im.getInfoGenerales();`
266		300
267	`r.rafraichir(meta, false);`	301	`r.rafraichir(meta, false);`
268	`}`	302	`}`
269		303
270	`/**`	304	`/**`
271	`* Va chercher les mots clés associés à une image dans la liste des images`	305	`* Va chercher les mots clés associés à une image dans la liste des images`
272	`* chargée dans le modèle`	306	`* chargée dans le modèle`
273	`*`	307	`*`
274	`* @param r`	308	`* @param r`
275	`* le rafraichissable auquel on enverra les informations`	309	`* le rafraichissable auquel on enverra les informations`
276	`* @param id`	310	`* @param id`
277	`* l'identifiant de l'image`	311	`* l'identifiant de l'image`
278	`*/`	312	`*/`
279	`public void obtenirMotsClesId(Rafraichissable r, String id) {`	313	`public void obtenirMotsClesId(Rafraichissable r, String id) {`
280		314
281	`String[] motsClesIdTab = getMotsClesId(id);`	315	`String[] motsClesIdTab = getMotsClesId(id);`
282	`r.rafraichir(motsClesIdTab, false);`	316	`r.rafraichir(motsClesIdTab, false);`
283	`}`	317	`}`
284		318
285	`public String[] getMotsClesId(String idImage) {`	319	`public String[] getMotsClesId(String idImage) {`
286	`ImageCarnet im = cacheImage.get(idImage);`	320	`ImageCarnet im = cacheImage.get(idImage);`
287	`String motsClesId = im.getMotsCles();`	321	`String motsClesId = im.getMotsCles();`
288	`String[] motsClesIdTab = motsClesId.split(",");`	322	`String[] motsClesIdTab = motsClesId.split(",");`
289		323
290	`return motsClesIdTab;`	324	`return motsClesIdTab;`
291	`}`	325	`}`
292		326
293	`/**`	327	`/**`
294	`* Va chercher le nom du mot clé associé à un id dans le cache local`	328	`* Va chercher le nom du mot clé associé à un id dans le cache local`
295	`*`	329	`*`
296	`* @param String id`	330	`* @param String id`
297	`* id du mot clé`	331	`* id du mot clé`
298	`* @return le mot clé associé à l'identifiant`	332	`* @return le mot clé associé à l'identifiant`
299	`*/`	333	`*/`
300	`public String obtenirTexteMotCle(String id) {`	334	`public String obtenirTexteMotCle(String id) {`
301		335
302	`String correspondanceId = "";`	336	`String correspondanceId = "";`
303		337
304	`String motCleTexte = motsCles.get(id);`	338	`String motCleTexte = motsCles.get(id);`
305		339
306	`if(motCleTexte != null) {`	340	`if(motCleTexte != null) {`
307	`correspondanceId = motCleTexte;`	341	`correspondanceId = motCleTexte;`
308	`}`	342	`}`
309		343
310	`return correspondanceId;`	344	`return correspondanceId;`
311	`}`	345	`}`
312		346
313	`/**`	347	`/**`
314	`* Construit une chaine contenant le texte des mots clés séparés par des virgules`	348	`* Construit une chaine contenant le texte des mots clés séparés par des virgules`
315	`*/`	349	`*/`
316	`public String renvoyerChaineMotClesTexte(ImageCarnet ic) {`	350	`public String renvoyerChaineMotClesTexte(ImageCarnet ic) {`
317	`String chaineMotsCles = ic.getMotsCles();`	351	`String chaineMotsCles = ic.getMotsCles();`
318	`String[] tabMotsCles = chaineMotsCles.split(",");`	352	`String[] tabMotsCles = chaineMotsCles.split(",");`
319	`String chaineMotsClesTexte = "";`	353	`String chaineMotsClesTexte = "";`
320	`for (int i = 0; i < tabMotsCles.length; i++) {`	354	`for (int i = 0; i < tabMotsCles.length; i++) {`
321	`chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);`	355	`chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);`
322	`chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";`	356	`chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";`
323	`}`	357	`}`
324	`return chaineMotsClesTexte;`	358	`return chaineMotsClesTexte;`
325	`}`	359	`}`
326		360
327	`/**`	361	`/**`
328	`* Met à jour la liste des images en local et appelle le DAO de mise à jour`	362	`* Met à jour la liste des images en local et appelle le DAO de mise à jour`
329	`* pour les commentaires et la date des images selectionnées`	363	`* pour les commentaires et la date des images selectionnées`
330	`*`	364	`*`
331	`* @param commentaires`	365	`* @param commentaires`
332	`* le commentaire à appliquer`	366	`* le commentaire à appliquer`
333	`* @param date`	367	`* @param date`
334	`* la date à appliquer`	368	`* la date à appliquer`
335	`* @param ids`	369	`* @param ids`
336	`* les identifiants des images selectionnées`	370	`* les identifiants des images selectionnées`
337	`*/`	371	`*/`
338	`public void mettreAJourCacheImage(String commentaires, String date,`	372	`public void mettreAJourCacheImage(String commentaires, String date,`
339	`String note, String ids[]) {`	373	`String note, String ids[]) {`
340	`for (int i = 0; i < ids.length; i++) {`	374	`for (int i = 0; i < ids.length; i++) {`
341	`String key = ids[i];`	375	`String key = ids[i];`
342	`ImageCarnet ic = cacheImage.get(key);`	376	`ImageCarnet ic = cacheImage.get(key);`
343	`ic.miseAJourInfoGenerales(commentaires, date, note);`	377	`ic.miseAJourInfoGenerales(commentaires, date, note);`
344	`mettreAjourBaseDeDonneesImageCarnet(ic);`	378	`mettreAjourBaseDeDonneesImageCarnet(ic);`
345	`}`	379	`}`
346		380
347	`}`	381	`}`
348		382
349	`/**`	383	`/**`
350	`* Ajoute un nouveau mot clés à la liste des mots clés locale`	384	`* Ajoute un nouveau mot clés à la liste des mots clés locale`
351	`*`	385	`*`
352	`* @param text`	386	`* @param text`
353	`* le mot clé`	387	`* le mot clé`
354	`* @param id`	388	`* @param id`
355	`* l'identifiant du mot clé`	389	`* l'identifiant du mot clé`
356	`*/`	390	`*/`
357	`public void mettreAjourMotsClesId(String text, String id) {`	391	`public void mettreAjourMotsClesId(String text, String id) {`
358	`motsCles.put(id, text);`	392	`motsCles.put(id, text);`
359	`}`	393	`}`
360		394
361	`/**`	395	`/**`
362	`* Appelle le DAO chargé de mettre à jour la base de données avec les toutes`	396	`* Appelle le DAO chargé de mettre à jour la base de données avec les toutes`
363	`* les informations des images modifiées par l'utilisateur`	397	`* les informations des images modifiées par l'utilisateur`
364	`*/`	398	`*/`
365	`public void mettreAJourBaseDeDonneesListeImageCarnet() {`	399	`public void mettreAJourBaseDeDonneesListeImageCarnet() {`
366	`ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);`	400	`ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);`
367		401
368	`liDaO.SynchroniserBaseDeDonnees(cacheImage);`	402	`liDaO.SynchroniserBaseDeDonnees(cacheImage);`
369	`}`	403	`}`
370		404
371	`/**`	405	`/**`
372	`* Appelle le DAO chargé de mettre à jour la base de données avec les toutes`	406	`* Appelle le DAO chargé de mettre à jour la base de données avec les toutes`
373	`* les informations d'une image donnée`	407	`* les informations d'une image donnée`
374	`*`	408	`*`
375	`* @param ic`	409	`* @param ic`
376	`* l'image à synchroniser avec la base`	410	`* l'image à synchroniser avec la base`
377	`*/`	411	`*/`
378	`public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {`	412	`public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {`
379	`ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);`	413	`ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);`
380	`iaDaO.SynchroniserBaseDeDonnees(ic);`	414	`iaDaO.SynchroniserBaseDeDonnees(ic);`
381	`}`	415	`}`
382		416
383	`/**`	417	`/**`
384	`* Supprime les images données du cache local et appelle le DAO qui les`	418	`* Supprime les images données du cache local et appelle le DAO qui les`
385	`* supprime de la base de données`	419	`* supprime de la base de données`
386	`*`	420	`*`
387	`* @param ids`	421	`* @param ids`
388	`* les identifiants des images selectionnées`	422	`* les identifiants des images selectionnées`
389	`*/`	423	`*/`
390	`public void supprimerImages(String[] ids) {`	424	`public void supprimerImages(String[] ids) {`
391	`String rids[] = new String[ids.length];`	425	`String rids[] = new String[ids.length];`
392	`ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);`	426	`ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);`
393		427
394	`for (int i = 0; i < ids.length; i++) {`	428	`for (int i = 0; i < ids.length; i++) {`
395	`String key = ids[i];`	429	`String key = ids[i];`
396	`ImageCarnet ic = cacheImage.get(key);`	430	`ImageCarnet ic = cacheImage.get(key);`
397	`rids[i] = ic.getId();`	431	`rids[i] = ic.getId();`
398		432
399	`cacheImage.remove(key);`	433	`cacheImage.remove(key);`
400	`}`	434	`}`
401		435
402	`if (rids.length != 0) {`	436	`if (rids.length != 0) {`
403	`liDao.supprimerBaseDeDonnees(rids);`	437	`liDao.supprimerBaseDeDonnees(rids);`
404	`}`	438	`}`
405	`}`	439	`}`
406		440
407	`/**`	441	`/**`
408	`* Met à jour les données locales suivant le type des nouvelles données et`	442	`* Met à jour les données locales suivant le type des nouvelles données et`
409	`* appelle le médiateur pour le notifier de la mise à jour`	443	`* appelle le médiateur pour le notifier de la mise à jour`
410	`*/`	444	`*/`
411	`@Override`	445	`@Override`
412	`public void rafraichir(Object nouvelleDonnees,`	446	`public void rafraichir(Object nouvelleDonnees,`
413	`boolean repandreRafraichissement) {`	447	`boolean repandreRafraichissement) {`
414	`// si l'on a reçu une liste d'images`	448	`// si l'on a reçu une liste d'images`
415	`if (nouvelleDonnees instanceof ListeImageCarnet) {`	449	`if (nouvelleDonnees instanceof ListeImageCarnet) {`
416	`ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;`	450	`ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;`
417	`Object[][] photoData = new Object[data.size()][13];`	451	`Object[][] photoData = new Object[data.size()][14];`
418	`int i = 0;`	452	`int i = 0;`
419		453
420	`if (data.size() == 0) {`	454	`if (data.size() == 0) {`
421	`pageEncours = 0;`	455	`pageEncours = 0;`
422	`}`	456	`}`
423		457
424	`// on la parse et on récupère les informations qui nous interessent`	458	`// on la parse et on récupère les informations qui nous interessent`
425	`for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {`	459	`for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {`
426	`ImageCarnet im = data.get(it.next());`	460	`ImageCarnet im = data.get(it.next());`
427	`photoData[i][0] = im.getOrdre();`	461	`photoData[i][0] = im.getOrdre();`
428	`photoData[i][1] = im.getNomOriginal();`	462	`photoData[i][1] = im.getNomOriginal();`
429	`photoData[i][2] = im.getDate();`	463	`photoData[i][2] = im.getDate();`
430	`photoData[i][3] = im.getIptcCity();`	464	`photoData[i][3] = im.getIptcCity();`
431	`photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();`	465	`photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();`
432	`photoData[i][5] = im.getUrlFormatListe();`	466	`photoData[i][5] = im.getUrlFormatListe();`
433	`photoData[i][6] = im.getUrlFormatGalerie();`	467	`photoData[i][6] = im.getUrlFormatGalerie();`
434	`photoData[i][7] = im.getUrlFormatZoom();`	468	`photoData[i][7] = im.getUrlFormatZoom();`
435	`photoData[i][8] = im.getNote();`	469	`photoData[i][8] = im.getNote();`
436	`photoData[i][9] = im.getId();`	470	`photoData[i][9] = im.getId();`
437	`photoData[i][10] = im.getTailleImage()[1];`	471	`photoData[i][10] = im.getTailleImage()[1];`
438	`photoData[i][11] = im.getTailleImage()[0];`	472	`photoData[i][11] = im.getTailleImage()[0];`
439	`photoData[i][12] = im.getIdsObsAssociees();`	473	`photoData[i][12] = im.getIdsObsAssociees();`
-		474	`photoData[i][13] = im.getIdsObsAssociees();`
440		475
441	`i++;`	476	`i++;`
442	`}`	477	`}`
443		-
444	`// creation du store qui les contient`	-
445	`FieldDef defNumImage = new IntegerFieldDef("num_image");`	-
446	`FieldDef defNomImage = new StringFieldDef("nom_original");`	-
447	`FieldDef defDatImage = new StringFieldDef("dat_image");`	-
448	`FieldDef defLieImage = new StringFieldDef("lie_image");`	-
449	`FieldDef defAppImage = new StringFieldDef("app_image");`	-
450	`FieldDef defUrlImageS = new StringFieldDef("url_image_S");`	-
451	`FieldDef defUrlImageM = new StringFieldDef("url_image_M");`	-
452	`FieldDef defUrlImage = new StringFieldDef("url_image");`	-
453	`FieldDef defNoteImage = new IntegerFieldDef("note_image");`	-
454	`FieldDef defIdImage = new IntegerFieldDef("id_image");`	-
-		478
455	`FieldDef defTailleX = new IntegerFieldDef("taille_x");`	-
456	`FieldDef defTailleY = new IntegerFieldDef("taille_y");`	-
457	`FieldDef defObsAssociees = new StringFieldDef("obs_associees");`	-
458	`FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage,`	-

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/image/ImageModele.java – Rev 2618 → 2726