| 2,6 → 2,7 |
|---|
| |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Vector; |
| |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.ImageAsynchroneDAO; |
| 10,9 → 11,12 |
|---|
| 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; |
| 33,35 → 37,81 |
|---|
| */ |
| 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 |
| 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 ; |
| 73,8 → 123,17 |
|---|
| */ |
| 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); |
| } |
| |
| /** |
| 217,10 → 276,12 |
|---|
| String key = ids[i] ; |
| ImageCarnet ic = (ImageCarnet)cacheImage.get(key) ; |
| rids[i] = ic.getId() ; |
| |
| cacheImage.remove(key) ; |
| } |
| |
| if(rids.length != 0) |
| { |
| { |
| liDao.supprimerBaseDeDonnees(rids); |
| } |
| } |
| 231,11 → 292,13 |
|---|
| */ |
| 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()); |
| 250,7 → 313,7 |
|---|
| 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"); |
| 269,7 → 332,13 |
|---|
| 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) ; |
| 276,14 → 345,18 |
|---|
| } |
| } |
| |
| // 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") ; |
| 293,9 → 366,10 |
|---|
| 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) ; |
| 306,6 → 380,7 |
|---|
| |
| 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() ; |
| 317,6 → 392,8 |
|---|
| } |
| 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) ; |
| 327,10 → 404,26 |
|---|
| parentNode.appendChild(node) ; |
| } |
| } |
| } |
| } |
| // enfin on met à jour l'arbre des mots clés contenu dans le modèle |
| rafraichirArbreMotsCles(arbreMotsCles) ; |
| getIMediateur().getMetadonneesIptcExif().getPanneauMotsCles().rafraichir(arbreMotsCles, true) ; |
| } |
| // 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]) ; |
| } |
| } |
| |
| /** |
| 510,4 → 603,64 |
|---|
| 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) ; |
| } |
| |
| } |