| /trunk/src/org/tela_botanica/client/image/ImageMediateur.java |
|---|
| 58,12 → 58,12 |
| private final Panel panneauPrincipalImage = new Panel("Images"); |
| /** |
| * panneau à onglet pour la liste, la galerie et la vue en grand |
| * panneau a onglet pour la liste, la galerie et la vue en grand |
| */ |
| private TabPanel ongletsImage = null ; |
| /** |
| * conteneur du panneau à onglets |
| * conteneur du panneau a onglets |
| */ |
| private Panel panneauMenuEtOngletsImage = null ; |
| 83,12 → 83,12 |
| private ZoomImageVue zoomImage = null ; |
| /** |
| * panneau à onglets affichant les métadonnées et les mots clés |
| * panneau a onglets affichant les métadonnées et les mots clés |
| */ |
| private PanneauMetadonneesVue metadonneesIptcExif = null ; |
| /** |
| * panneau conteneur pour le panneau à onglet des metadonnées |
| * panneau conteneur pour le panneau a onglet des metadonnées |
| */ |
| private final Panel detailsEtMotsCles = new Panel("Détails et mots clés"); |
| 113,7 → 113,7 |
| private boolean selection = false ; |
| /** |
| * constructeur privé (on accède à la classe par la méthode getInstance |
| * constructeur privé (on accède a la classe par la méthode getInstance |
| */ |
| private ImageMediateur() |
| { |
| 129,6 → 129,7 |
| iModele = ImageModele.Instance(this); |
| iModele.initialiserArbreMotsCles() ; |
| panneauPrincipalImage.setLayout(new BorderLayout()); |
| panneauMenuEtOngletsImage = new Panel() ; |
| 305,9 → 306,9 |
| } |
| /** |
| * met à jour les données provenant du modèle et synchronise les vues entre elles |
| * @param o données de mises à jour pour les vues |
| * @param r le refraichissable qui a demandé la mise à jour |
| * met a jour les données provenant du modèle et synchronise les vues entre elles |
| * @param o données de mises a jour pour les vues |
| * @param r le refraichissable qui a demandé la mise a jour |
| */ |
| public void synchroniserDonneesZoomListeGalerie(Object o, Rafraichissable r) |
| { |
| 344,8 → 345,8 |
| } |
| /** |
| * envoie au modèle une demande de mise à jour |
| * @param r la vue demandeuse de mise à jour |
| * envoie au modèle une demande de mise a jour |
| * @param r la vue demandeuse de mise a jour |
| */ |
| public void obtenirPhotoGalerie(Rafraichissable r) |
| { |
| 353,8 → 354,8 |
| } |
| /** |
| * demande au modèle les métadonnées associées à une image |
| * @param r la vue demandeuse de mise à jour |
| * demande au modèle les métadonnées associées a une image |
| * @param r la vue demandeuse de mise a jour |
| * @param id l'identifiant de l'image |
| */ |
| public void obtenirMetadonnees(Rafraichissable r, String id) |
| 363,8 → 364,8 |
| } |
| /** |
| * demande au modèle les ids des mots clés associés à une image |
| * @param r la vue demandeuse de mise à jour |
| * demande au modèle les ids des mots clés associés a une image |
| * @param r la vue demandeuse de mise a jour |
| * @param id l'identifiant de l'image |
| */ |
| public void obtenirMotsClesId(Rafraichissable r, String id) |
| 372,9 → 373,14 |
| getIModele().obtenirMotsClesId(r, id) ; |
| } |
| public void obtenirArbreMotsCles(Rafraichissable r) |
| { |
| getIModele().obtenirArbreMotCle(r) ; |
| } |
| /** |
| * envoie au modèle une demande de mise à jour des informations modifiables |
| * associées à une image |
| * envoie au modèle une demande de mise a jour des informations modifiables |
| * associées a une image |
| * @param commentaires le commentaire de l'image |
| * @param date la date modifiée par l'utilisateur |
| */ |
| 385,6 → 391,11 |
| getIModele().mettreAJourCacheImage(commentaires, date, ids) ; |
| } |
| public void rafraichirArbreMotsCles(Tree arbreMC) |
| { |
| metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false) ; |
| } |
| /** |
| * envoie au modèle une demande pour lancer le formulaire ou l'application d'upload |
| */ |
| 451,7 → 462,7 |
| } |
| /** |
| * envoie une demande de mise à jour des données au modèle |
| * envoie une demande de mise a jour des données au modèle |
| */ |
| public void rafraichirToutesVues() |
| { |
| 515,7 → 526,7 |
| if(arg.equals("prev")) |
| { |
| // si la photo séléctionnée est la première, on passe à la |
| // si la photo séléctionnée est la première, on passe a la |
| // dernière |
| if (selected == 0) { |
| storeIndex = st.getCount() - 1 ; |
| 533,7 → 544,7 |
| if(arg.equals("suiv")) |
| { |
| // si la photo selectionnée est la dernière on passe à la |
| // si la photo selectionnée est la dernière on passe a la |
| // première |
| if (selected == st.getCount() - 1) { |
| 570,7 → 581,7 |
| /** |
| * synchronise la selection entre la galerie et la liste |
| * @param string le nom de la vue qui doit être synchronisée |
| * @param string le nom de la vue qui doit être synchronisee |
| */ |
| public void synchroniserSelection(String string) { |
| 598,7 → 609,7 |
| /** |
| * fait une demande de suppression des images (en local et en distant) |
| * des images selectionnées |
| * des images selectionnees |
| */ |
| public void supprimerImages() { |
| 618,7 → 629,7 |
| { |
| if(com.google.gwt.user.client.Window |
| .confirm("Supprimer les images sélectionnées ?")) |
| .confirm("Supprimer les images selectionnees ?")) |
| { |
| getIModele().supprimerImages(ids) ; |
| aucuneSelection() ; |
| 626,13 → 637,13 |
| } |
| else |
| { |
| Window.alert("Impossible de supprimer : aucune image selectionnée") ; |
| Window.alert("Impossible de supprimer : aucune image selectionnee") ; |
| } |
| } |
| /** |
| * désactive les onglets de métadonnées et de zoom (dans le cas ou rien n'est selectionné) |
| * desactive les onglets de metadonnees et de zoom (dans le cas ou rien n'est selectionne) |
| */ |
| public void aucuneSelection() { |
| 646,7 → 657,7 |
| } |
| /** |
| * réacative les onglet métadonnées et zoom (lors d'une sélection alors qu'il n'y en avait pas) |
| * reacative les onglet metadonnees et zoom (lors d'une selection alors qu'il n'y en avait pas) |
| */ |
| public void selection() { |
| 661,8 → 672,8 |
| public void montrerContextMenuArbre(final TreeNode n, EventObject ev, final TreeEditor te) |
| { |
| Menu mn = new Menu() ; |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item("Ajouter mot clé"); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item("Supprimer mot clé"); |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item("Ajouter mot cle"); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item("Supprimer mot cle"); |
| mn.addItem(ajoutN); |
| mn.addItem(suppN); |
| 670,8 → 681,7 |
| mn.addListener(new MenuListenerAdapter() { |
| public void onItemClick(BaseItem item, EventObject e) |
| { |
| { |
| if(item.equals(suppN)) |
| { |
| getMetadonneesIptcExif().getPanneauMotsCles().supprimerNoeud(n) ; |
| 686,6 → 696,8 |
| mn.showAt(ev.getXY()); |
| } |
| public void mettreAjourMotsClesId(String text, String id) { |
| 721,6 → 733,11 |
| getIModele().deplacerMotCleDansArbre(n, arbreMC) ; |
| } |
| public void initialiserMotsCleCoches() { |
| obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), getGalerieImage().getIdSelectionnees()[0]) ; |
| } |
| /trunk/src/org/tela_botanica/client/image/ImageModele.java |
|---|
| 11,6 → 11,8 |
| import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO; |
| 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; |
| 41,10 → 43,8 |
| private Store st = null ; |
| private com.gwtext.client.data.Tree arbreMotsCles = null ; |
| private com.gwtext.client.data.Tree arbreMotsCles = new Tree() ; |
| private String arbreAplati = "" ; |
| static ImageModele Instance(ImageMediateur im) |
| { |
| if(!estInstancie) |
| 67,6 → 67,10 |
| 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) |
| { |
| ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(); |
| 73,6 → 77,10 |
| liaDAO.ObtenirListeImages(this); |
| } |
| /** |
| * 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() ; |
| 80,37 → 88,60 |
| 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) ; |
| 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(",") ; |
| 118,6 → 149,13 |
| 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++) |
| 129,16 → 167,20 |
| } |
| } |
| /** |
| * 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) ; |
| } |
| public void mettreAjourBaseDeDonneesMotsClesId() |
| { |
| } |
| /** |
| * 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(); |
| 147,6 → 189,11 |
| 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(); |
| 154,15 → 201,19 |
| iaDaO.SynchroniserBaseDeDonnees(ic) ; |
| } |
| public void supprimerImages(String[] ids) { |
| /** |
| * 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++) { |
| for (int i = 0; i < ids.length; i++) |
| { |
| String key = ids[i] ; |
| ImageCarnet ic = (ImageCarnet)cacheImage.get(key) ; |
| rids[i] = ic.getId() ; |
| 171,58 → 222,120 |
| if(rids.length != 0) |
| { |
| liDao.supprimerBaseDeDonnees(rids); |
| } |
| } |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| /** |
| * 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) |
| { |
| if(nouvelleDonnees instanceof ListeImageCarnet) |
| { |
| ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ; |
| Object[][] photoData = new Object[data.size()][7]; |
| int i = 0 ; |
| 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++ ; |
| } |
| ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ; |
| Object[][] photoData = new Object[data.size()][7]; |
| int i = 0 ; |
| 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() ; |
| // creation du store |
| 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) ; |
| i++ ; |
| } |
| // creation du store |
| 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 ; |
| final MemoryProxy dataProxy = new MemoryProxy(photoData); |
| final ArrayReader reader = new ArrayReader(rd); |
| final Store photoStore = new Store(dataProxy, reader); |
| if(repandreRafraichissement) |
| { |
| getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ; |
| } |
| } |
| if(nouvelleDonnees instanceof JSONArray) |
| { |
| JSONArray reponse = (JSONArray)nouvelleDonnees ; |
| rafraichirListeImage(nouvelleDonnees); |
| final int taillemax = reponse.size(); |
| st = photoStore ; |
| if(repandreRafraichissement) |
| if(taillemax == 0) |
| { |
| getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ; |
| TreeNode root = new TreeNode() ; |
| root.setId("racine") ; |
| root.setText("Tags") ; |
| root.setIcon("tela.png") ; |
| String[] usObj = {"Tags","racine"} ; |
| root.setUserObject(usObj) ; |
| arbreMotsCles.setRootNode(root) ; |
| } |
| for (int j = 0; j < taillemax ; j++) |
| { |
| 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} ; |
| 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 |
| { |
| 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) ; |
| } |
| } |
| } |
| rafraichirArbreMotsCles(arbreMotsCles) ; |
| getIMediateur().getMetadonneesIptcExif().getPanneauMotsCles().rafraichir(arbreMotsCles, true) ; |
| } |
| } |
| /** |
| * Affiche les paires / valeur de tous les mots clés stockés |
| */ |
| public void afficherMotsCles() |
| { |
| for(Iterator it = motsCles.keySet().iterator() ; it.hasNext() ;) |
| 233,14 → 346,24 |
| } |
| } |
| public void mettreAjourMotsCles(String[] ids, String motsClesEnCours, com.gwtext.client.data.Tree arbreMC) { |
| for (int i = 0; i < ids.length; i++) { |
| /** |
| * 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) ; |
| } |
| } |
| 247,9 → 370,35 |
| 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) ; |
| } |
| public void ajouterMotCleDansArbre(TreeNode n, com.gwtext.client.data.Tree arbreMC) { |
| /** |
| * 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()) ; |
| 256,8 → 405,8 |
| String[] usObj = (String[])n.getUserObject() ; |
| String motCle = usObj[0] ; |
| String id = usObj[1] ; |
| String parentId = "" |
| ; |
| String parentId = "" ; |
| if(!id.equals("racine")) |
| { |
| String[] parentUsObj = (String[])n.getParentNode().getUserObject() ; |
| 271,11 → 420,17 |
| rafraichirArbreMotsCles(arbreMC) ; |
| String nouveauMotCle = "&motcle="+motCle+"&id="+id+"&parent="+parentId ; |
| MCDao.ajouterBaseDeDonnees(nouveauMotCle) ; |
| MCDao.ajouterBaseDeDonnees(nouveauMotCle) ; |
| } |
| public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| /** |
| * 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()) ; |
| 290,7 → 445,14 |
| } |
| public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) { |
| /** |
| * 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()) ; |
| 298,8 → 460,8 |
| String[] usObj = (String[])n.getUserObject() ; |
| String motCle = usObj[0] ; |
| String id = usObj[1] ; |
| String parentId = "" |
| ; |
| String parentId = "" ; |
| if(!id.equals("racine")) |
| { |
| String[] parentUsObj = (String[])n.getParentNode().getUserObject() ; |
| 312,12 → 474,17 |
| rafraichirArbreMotsCles(arbreMC) ; |
| String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ; |
| 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() ; |
| 326,8 → 493,7 |
| String[] usObj = (String[])n.getUserObject() ; |
| String motCle = usObj[0] ; |
| String id = usObj[1] ; |
| String parentId = "" |
| ; |
| String parentId = "" ; |
| if(!id.equals("racine")) |
| { |
| String[] parentUsObj = (String[])n.getParentNode().getUserObject() ; |
| 340,8 → 506,7 |
| rafraichirArbreMotsCles(arbreMC) ; |
| String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ; |
| String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ; |
| MCDao.deplacerBaseDeDonnees(motCleModifie) ; |
| } |
| /trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java |
|---|
| 24,8 → 24,13 |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListener; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ComponentListener; |
| import com.gwtext.client.widgets.event.ComponentListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.EditorListener; |
| import com.gwtext.client.widgets.event.EditorListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| 47,8 → 52,11 |
| private TextField tfEdit = null ; |
| private Button valider = null ; |
| private String motsClesEnCours = "" ; |
| private String[] motsClesEnAttente ; |
| private boolean ajoutNoeud = false ; |
| private boolean modifNoeud = false ; |
| private boolean estInstancie = false ; |
| private boolean motsCleInitialises ; |
| public ArbreMotsClesVue(ImageMediateur im) |
| { |
| 59,13 → 67,13 |
| arbreMotsCles = new TreePanel() ; |
| arbreMotsCles.setEnableDD(true) ; |
| TreeNode root = new TreeNode("Mots clés") ; |
| TreeNode root = new TreeNode("Tags") ; |
| root.setId("racine") ; |
| String[] usObject = {"Mots clés" , "racine" } ; |
| root.setUserObject(usObject) ; |
| arbreMotsCles.setRootNode(root) ; |
| arbreMotsCles.setRootVisible(true) ; |
| arbreMotsCles.setRootVisible(false) ; |
| arbreMotsCles.getRootNode().setIcon("tela.png") ; |
| tfEdit = new TextField() ; |
| 76,6 → 84,7 |
| this.add(valider,new RowLayoutData("10%")) ; |
| ajouterListeners() ; |
| } |
| private ImageMediateur GetIMediateur() { |
| 118,8 → 127,8 |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent() ; |
| GetIMediateur().montrerContextMenuArbre(node, e , getTe()) ; |
| e.stopEvent() ; |
| GetIMediateur().montrerContextMenuArbre(node, e , getTe()) ; |
| } |
| 157,7 → 166,6 |
| } |
| public void onCheckChange(TreeNode node, boolean checked) { |
| if(checked) |
| 174,9 → 182,9 |
| }) ; |
| } |
| } |
| }) ; |
| valider.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| 207,11 → 215,26 |
| } |
| public void obtenirArbreMotsCles() { |
| GetIMediateur().obtenirArbreMotsCles(this) ; |
| } |
| public void supprimerNoeud(TreeNode n) |
| { |
| n.getParentNode().removeChild(n); |
| n.destroy() ; |
| GetIMediateur().supprimerMotCleDansArbre(n, arbreMotsCles.getTree()) ; |
| if(!n.getId().equals(getArbreMotsCles().getRootNode().getId())) |
| { |
| n.getParentNode().removeChild(n); |
| n.destroy() ; |
| GetIMediateur().supprimerMotCleDansArbre(n, arbreMotsCles.getTree()) ; |
| } |
| else |
| { |
| Window.alert("Impossible de supprimer la racine de l'arbre") ; |
| } |
| } |
| public void ajouterNoeud(TreeNode parent) |
| 245,27 → 268,30 |
| public void cocherMotsCles(final String[] motsClesIds) |
| { |
| getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() { |
| public boolean execute(Node node) { |
| for(int i = 0 ; i < motsClesIds.length ; i++) |
| { |
| String usObject[] = (String[])node.getUserObject() ; |
| String nodeId = usObject[1] ; |
| if(getArbreMotsCles() != null && getArbreMotsCles().getRootNode() != null) |
| { |
| getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() { |
| public boolean execute(Node node) { |
| getArbreMotsCles().getNodeById(node.getId()).getUI().toggleCheck(false) ; |
| if(nodeId.equals(motsClesIds[i])) |
| { |
| getArbreMotsCles().getNodeById(nodeId).getUI().toggleCheck(true) ; |
| return true ; |
| } |
| for(int i = 0 ; i < motsClesIds.length ; i++) |
| { |
| String usObject[] = (String[])node.getUserObject() ; |
| String nodeId = usObject[1] ; |
| getArbreMotsCles().getNodeById(node.getId()).getUI().toggleCheck(false) ; |
| if(nodeId.equals(motsClesIds[i])) |
| { |
| getArbreMotsCles().getNodeById(nodeId).getUI().toggleCheck(true) ; |
| return true ; |
| } |
| } |
| return true; |
| } |
| return true; |
| } |
| }) ; |
| }) ; |
| } |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| 273,14 → 299,31 |
| if(nouvelleDonnees instanceof Tree) |
| { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| getArbreMotsCles().setRootNode(nouvelArbre.getRootNode()) ; |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| getArbreMotsCles().getRootNode().appendChild(nouvelArbre.getRootNode()) ; |
| getArbreMotsCles().expandAll() ; |
| estInstancie = true ; |
| if(motsCleInitialises == false && motsClesEnAttente != null) |
| { |
| cocherMotsCles(motsClesEnAttente) ; |
| motsCleInitialises = true ; |
| } |
| } |
| if(nouvelleDonnees instanceof String[]) |
| { |
| String[] motsClesIds = (String[])nouvelleDonnees ; |
| cocherMotsCles(motsClesIds) ; |
| if(estInstancie && nouvelleDonnees != null) |
| { |
| String[] motsClesIds = (String[])nouvelleDonnees ; |
| cocherMotsCles(motsClesIds) ; |
| } |
| else |
| { |
| motsClesEnAttente = (String[])nouvelleDonnees ; |
| } |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/PanneauMetadonneesVue.java |
|---|
| 128,7 → 128,7 |
| IptcGrid.setSorted(false); |
| panneauExifGrid.add(ExifGrid); |
| panneauIptcGrid.add(IptcGrid); |
| panneauIptcGrid.add(IptcGrid); |
| this.doLayout(true) ; |
| /trunk/src/org/tela_botanica/client/modeles/ImageCarnet.java |
|---|
| 61,10 → 61,10 |
| if(this.containsKey((cle))) |
| { |
| String valeur = (String)this.get(cle) ; |
| if(valeur.equals("null")) |
| if(valeur.equals("null") || valeur == null) |
| { |
| return "null" ; |
| } |
| } |
| else |
| { |
| char nullChar = '\u0000' ; |
| /trunk/src/org/tela_botanica/client/modeles/ImageAsynchroneDAO.java |
|---|
| 28,7 → 28,6 |
| String key = (String)imgIt.next() ; |
| String valeur = ic.renvoyerValeurCorrecte(key) ; |
| postData += "&"+key+"="+valeur ; |
| } |
| 42,6 → 41,23 |
| }) ; |
| } |
| public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) |
| { |
| String postData = "" ; |
| String motsCles = ic.getMotsCles() ; |
| String id = ic.getId() ; |
| postData += "&ci_id_image="+id+"&ci_meta_mots_cles="+motsCles ; |
| HTTPRequest.asyncPost("jrest/inventoryImage/0/", postData, new ResponseTextHandler() { |
| public void onCompletion(String responseText) { |
| } |
| }) ; |
| } |
| public void supprimerBaseDeDonnees(final ImageCarnet ic) |
| { |
| String postData = "" ; |
| /trunk/src/org/tela_botanica/client/modeles/MotsClesAsynchroneDAO.java |
|---|
| 6,9 → 6,15 |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.json.client.JSONArray; |
| import com.google.gwt.json.client.JSONObject; |
| import com.google.gwt.json.client.JSONParser; |
| import com.google.gwt.json.client.JSONValue; |
| import com.google.gwt.user.client.HTTPRequest; |
| import com.google.gwt.user.client.ResponseTextHandler; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| public class MotsClesAsynchroneDAO { |
| 20,15 → 26,20 |
| iMediateur = im ; |
| } |
| public void obtenirListeMotsCles(Rafraichissable r) |
| public void obtenirListeMotsCles(final Rafraichissable r) |
| { |
| HTTPRequest.asyncGet("jrest/InventoryKeyWordList/"+iMediateur.getIdentifiant(), new ResponseTextHandler() { |
| public void onCompletion(String responseText) { |
| // TODO Auto-generated method stub |
| } |
| final JSONValue responseValue = JSONParser.parse(responseText); |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| r.rafraichir(reponse, true) ; |
| } |
| } |
| }); |
| } |
| 43,6 → 54,12 |
| public void onCompletion(String responseText) { |
| if(responseText.equals("ERROR")) |
| { |
| Window.alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application," + |
| "nous vous invitons à recharger la page. ") ; |
| } |
| } |
| }) ; |
| 60,7 → 77,11 |
| public void onCompletion(String responseText) { |
| if(responseText.equals("ERROR")) |
| { |
| Window.alert("Attention, la base de données des mots clés n'est plus synchronisée avec l'application," + |
| "nous vous invitons à recharger la page. ") ; |
| } |
| } |
| }) ; |
| 79,7 → 100,6 |
| public void onCompletion(String responseText) { |
| Window.alert(responseText) ; |
| } |
| 88,7 → 108,7 |
| } |
| public void deplacerBaseDeDonnees(String motcle) { |
| public void deplacerBaseDeDonnees(String motcle) { |
| if(!motcle.equals("")) |
| { |
| 100,7 → 120,6 |
| public void onCompletion(String responseText) { |
| Window.alert(responseText) ; |
| } |
| /trunk/src/org/tela_botanica/client/modeles/Observation.java |
|---|
| 46,7 → 46,7 |
| /** |
| * @param transmis |
| * @param nomSaisi |
| * @param nomretenu |
| * @param nomRetenu |
| * @param numeroNomenclatural |
| * @param numeroTaxonomique |
| * @param famille |