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 java.util.Vector;
 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.ListeImageCarnet;
 import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
 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.core.Ext;
+import com.gwtext.client.core.ExtElement;
 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.NodeTraversalCallback;
 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 ;
+	/**
-	private static boolean estInstancie = false ;
+	 * Le médiateur associé au modèle
 	 */
+	private ImageMediateur iMediateur = null ;
+	/**
-	private ImageMediateur iMediateur = null ;
+	 * La liste des image affichées en cours
 	 */
+	private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;
+	/**
-	private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;
+	 * Table de correspondance entre les mots clés et leurs identifiants
 	 */
+	private HashMap motsCles = new HashMap(0) ;
+	/**
-	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 ;
+	/**
-	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
-	private com.gwtext.client.data.Tree arbreMotsCles =  new Tree() ;
+	 * @return l'instance du modèle
 	 */
+	static ImageModele Instance(ImageMediateur im)
 	static ImageModele Instance(ImageMediateur im)
 		// si le modèle n'est pas encore instancié
+		if(!estInstancie)
 		if(!estInstancie)
 			// on en crée un nouveau
 			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 à associé
 	 */
 	private ImageModele(ImageMediateur im) {
 		iMediateur = im ;
+	}
+	/**
+	 * Accesseur pour le médiateur
+	 * @return
 	 */
 	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)
+	{
+		// on rassemble les critères
+		String[][] criteres = {{"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} } ;
+		// 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() ;
+		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} } ;
+		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
 		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO();
-		liaDAO.ObtenirListeImages(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() ;
 		IuADaO.setIMediateur(getIMediateur());
 		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 ids[])
+	{
 			for (int i = 0; i < ids.length; i++)
+			{
 				String key = ids[i] ;
 				ImageCarnet ic = (ImageCarnet)cacheImage.get(key) ;
 				ic.miseAJourInfoGenerales(commentaires, date) ;
 				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();
 		liDaO.setIMediateur(iMediateur);
 		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();
 		iaDaO.setIMediateur(iMediateur);
 		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() ;
 		liDao.setIMediateur(iMediateur);
 		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()][7];
 				int i = 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.getUrl() ;
 					i++ ;
+				}
-				// creation du store
+				// 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[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage};
 				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().getMetadonneesIptcExif().getPanneauMotsCles().rafraichir(arbreMotsCles, true) ;
+				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() ;
 				imgDao.setIMediateur(getIMediateur()) ;
 				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() ;
 		MCDao.setIMediateur(getIMediateur()) ;
 		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() ;
 		MCDao.setIMediateur(getIMediateur()) ;
 		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() ;
 		MCDao.setIMediateur(getIMediateur()) ;
 		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() ;
 		MCDao.setIMediateur(getIMediateur()) ;
 		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() ;
 		MCDao.setIMediateur(getIMediateur()) ;
 		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 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) ;
+	}
+}

Subversion Repositories eFlore/Archives.cel-v2

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