WebSVN – eFlore/Archives.cel-v2 – 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 org.tela_botanica.client.interfaces.Rafraichissable;
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.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeImageCarnet;
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 médiateur associé au modèle
	 */
	private ImageMediateur iMediateur = 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 motsCles = new HashMap(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 ;
	
	/**
	 * 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 ;
			return new ImageModele(im);
		}
		else
		{
			// sinon on renvoit null, interdisant explicitement la création d'un autre exemplaire
			return null ;
		}
	}
	
	/**
	 * 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 ;
	}
	
	/**
	 * 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 obtenirPhotoGalerie(Rafraichissable r)
	{
		String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;
		
		// on rassemble les critères
		String[][] criteres = {{"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()}, {motsClesFiltres[0][0], motsClesFiltres[0][1]}, {motsClesFiltres[1][0],motsClesFiltres[1][1] }} ;
		// 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) ;
		
		// ensuite on demande la page correspondante avec les mêmes critères
		String[][] criteres2 = { {"ci_limite" ,""+taillePage },{"ci_numero_page",""+pageEncours}, {motsClesFiltres[0][0], motsClesFiltres[0][1]}, {motsClesFiltres[1][0],motsClesFiltres[1][1] }} ;
		// 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
	 */
	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
	 */
	public void rafraichirMotsCles(Object o)
	{
		motsCles = (HashMap)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 = (ImageCarnet)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 = (ImageCarnet)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 = (ImageCarnet)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()][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 it = data.keySet().iterator(); it.hasNext();) 
				{
					ImageCarnet im = (ImageCarnet) 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") ;
 
			
				// 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") ;
				root.setIcon("tela.png") ;
				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.setIcon("tela.png") ;
						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.setIcon("tela.png") ;
						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]) ;
		}
	}
	
	/**
	 * Affiche les paires / valeur de tous les mots clés stockés
	 */
	public void afficherMotsCles()
	{
		for(Iterator it = motsCles.keySet().iterator() ; it.hasNext() ;)
		{
			String key = (String)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 = "&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 motCle = usObj[0] ;
		String id = usObj[1] ;
		
		String motCleASupprimer = id ;
		
		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 ;
			obtenirPhotoGalerie(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) ;
		obtenirPhotoGalerie(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  ((ImageCarnet)cacheImage.get(id)).getTailleImage() ;
		
	}
 
	public void obtenirNote(Rafraichissable r, String id) {
		
		r.rafraichir(((ImageCarnet)cacheImage.get(id)).getNote() ,true) ;
		
	}
	
}

Subversion Repositories eFlore/Archives.cel-v2

(root)/trunk/src/org/tela_botanica/client/image/ImageModele.java @ 31 – Rev 46 → 48

Rev 46		Rev 48
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;`	-
6		5
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	6	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.ImageAsynchroneDAO;`	7	`import org.tela_botanica.client.modeles.ImageAsynchroneDAO;`
9	`import org.tela_botanica.client.modeles.ImageCarnet;`	8	`import org.tela_botanica.client.modeles.ImageCarnet;`
10	`import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;`	9	`import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;`
11	`import org.tela_botanica.client.modeles.ListeImageCarnet;`	-
12	`import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;`	10	`import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;`
-		11	`import org.tela_botanica.client.modeles.ListeImageCarnet;`
13	`import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;`	12	`import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;`
14	`import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;`	13	`import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;`
15	`import org.tela_botanica.client.vues.BarreNotationVue;`	-
16		14
17	`import com.google.gwt.json.client.JSONArray;`	15	`import com.google.gwt.json.client.JSONArray;`
18	`import com.google.gwt.json.client.JSONObject;`	16	`import com.google.gwt.json.client.JSONObject;`
19	`import com.gwtext.client.core.Ext;`	-
20	`import com.gwtext.client.core.ExtElement;`	-
21	`import com.gwtext.client.data.ArrayReader;`	17	`import com.gwtext.client.data.ArrayReader;`
22	`import com.gwtext.client.data.FieldDef;`	18	`import com.gwtext.client.data.FieldDef;`
23	`import com.gwtext.client.data.IntegerFieldDef;`	19	`import com.gwtext.client.data.IntegerFieldDef;`
24	`import com.gwtext.client.data.MemoryProxy;`	20	`import com.gwtext.client.data.MemoryProxy;`
25	`import com.gwtext.client.data.Node;`	21	`import com.gwtext.client.data.Node;`
26	`import com.gwtext.client.data.NodeTraversalCallback;`	-
27	`import com.gwtext.client.data.RecordDef;`	22	`import com.gwtext.client.data.RecordDef;`
28	`import com.gwtext.client.data.Store;`	23	`import com.gwtext.client.data.Store;`
29	`import com.gwtext.client.data.StringFieldDef;`	24	`import com.gwtext.client.data.StringFieldDef;`
30	`import com.gwtext.client.data.Tree;`	25	`import com.gwtext.client.data.Tree;`
31	`import com.gwtext.client.widgets.tree.TreeNode;`	26	`import com.gwtext.client.widgets.tree.TreeNode;`
32		27
33	`/**`	28	`/**`
34	`* Modèle d'accès aux données pour les images.`	29	`* Modèle d'accès aux données pour les images.`
35	`* C'est un singleton`	30	`* C'est un singleton`
36	`* @author aurelien`	31	`* @author aurelien`
37	`*`	32	`*`
38	`*/`	33	`*/`
39	`public class ImageModele implements Rafraichissable {`	34	`public class ImageModele implements Rafraichissable {`