Subversion Repositories eFlore/Applications.cel

Compare Revisions

Problem with comparison.

Ignore whitespace Rev HEAD → Rev 610

/trunk/src/org/tela_botanica/client/image/ImageMediateur.java
New file
0,0 → 1,1712
package org.tela_botanica.client.image;
 
 
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.IdVue;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.vues.ArbreMotsClesVue;
import org.tela_botanica.client.vues.image.BarreOutilsVue;
import org.tela_botanica.client.vues.image.BarreRechercheFiltreVue;
import org.tela_botanica.client.vues.image.GalerieImageVue;
import org.tela_botanica.client.vues.image.ListeImageVue;
import org.tela_botanica.client.vues.image.MenuImageVue;
import org.tela_botanica.client.vues.image.MiniListeObservationVue;
import org.tela_botanica.client.vues.image.PanneauFiltresImagesVues;
import org.tela_botanica.client.vues.image.PanneauMetadonneesVue;
import org.tela_botanica.client.vues.image.ZoomImageVue;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.DataView;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.MessageBox.AlertCallback;
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.PanelListener;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.event.TabPanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
* Mediateur gérant les interactions entre vues et les echanges de données C'est
* un singleton.
*
* @author aurelien
*
*/
 
// TODO : Deporter les methodes de ListePaginable dans la liste d'images
 
public class ImageMediateur implements ListePaginable{
 
/**
* le mediateur des observations qui lie la partie images au carnet
*/
private CarnetEnLigneMediateur cMediateur = null;
 
private static ImageMediateur thisMediateur = null ;
/**
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false;
 
/**
* modele de données
*/
private ImageModele iModele = null;
 
/**
* L'identifiant utilisateur. Par défaut, il vaut 0
*/
private String identifiant = "0";
 
/**
* panneau principal des images (onglet "images")
*/
private Panel panneauPrincipalImage = null ;
 
/**
* panneau a onglet pour la liste, la galerie et la vue en grand
*/
private TabPanel ongletsImage = null;
 
/**
* panneau de filtrage
*/
private PanneauFiltresImagesVues filtres = null;
 
/**
* conteneur du panneau a onglets
*/
private Panel panneauMenuEtOngletsImage = null;
 
/**
* galerie de miniature
*/
private GalerieImageVue galerieImage = null;
 
/**
* liste détaillée des images
*/
private ListeImageVue listeImage = null;
 
/**
* vue agrandie de la l'image selectionnée
*/
private ZoomImageVue zoomImage = null;
 
/**
* panneau a onglets affichant les métadonnées et les mots clés
*/
private PanneauMetadonneesVue metadonneesIptcExif = null;
 
/**
* panneau conteneur pour le panneau a onglet des metadonnées
*/
private final Panel detailsEtMotsCles = new Panel("Détails et mots clés");
 
/**
* menu contextuel de manipulation des images
*/
private MenuImageVue menuImageVue = null;
 
/**
* barre d'outils
*/
private BarreOutilsVue barreOutilsVue = null;
 
/**
* l'indice du dernier onglet sélectionné
*/
private int dernierIndexOnglet = 0;
 
/**
* booleen explicitant s'il y a une selection en cours
*/
private boolean selection = false;
 
 
/**
* Filtre pour les commentaires
*/
private BarreRechercheFiltreVue filtreCommentaires = null;
/**
* Boolean indiquand si le médiateur a seulement été crée ou bien si tous
* les composants ont été crées
*/
private boolean estInitialise = false;
 
/**
* constructeur privé (on accède a la classe par la méthode getInstance)
*/
private ImageMediateur() {
initialiser() ;
}
 
/**
* constructeur avec paramètres privé (on accède a la classe par la méthode
* getInstance)
*
* @param cm
* le médiateur du carnet à associer à la partie image
*/
private ImageMediateur(CarnetEnLigneMediateur cm) {
cMediateur = cm;
panneauPrincipalImage = new Panel("Images") ;
panneauPrincipalImage.addListener(new PanelListenerAdapter() {
public boolean doBeforeRender(Component c) {
if(!estInitialise) {
initialiser() ;
}
return true;
}
});
}
 
/**
* Change la valeur du booleen de selection
*
* @param selection
* la nouvelle valeur du booléen
*/
public void setSelection(boolean selection) {
this.selection = selection;
}
 
/**
* renvoie la valeur du booleen de selection
*
* @return la valeur du booleen de selection
*/
public boolean isSelection() {
return selection;
}
 
/**
* Retourne une instance de manière unique
*
* @return l'instance unique du médiateur
*/
public static ImageMediateur Instance() {
if (!estInstancie && thisMediateur == null) {
// on en crée un nouveau
estInstancie = true;
thisMediateur = new ImageMediateur();
}
// sinon on retourne le "pointeur" vers le médiateur lui-même
return thisMediateur;
}
 
/**
* Retourne une instance de manière unique en lui associant un médiateur
* pour les observations
*
* @param cm le médiateur de carnet à associer
* @return l'instance unique du médiateur
*/
public static ImageMediateur Instance(CarnetEnLigneMediateur cm) {
if (!estInstancie && thisMediateur == null) {
// on en crée un nouveau
estInstancie = true;
thisMediateur = new ImageMediateur(cm);
}
// sinon on retourne le "pointeur" vers le médiateur lui-même
return thisMediateur;
}
private void initialiser()
{
// quelques variables de position pour les borderlayouts
final BorderLayoutData regionNord = new BorderLayoutData(
RegionPosition.NORTH);
 
final BorderLayoutData regionCentre = new BorderLayoutData(
RegionPosition.CENTER);
 
final BorderLayoutData regionEst = new BorderLayoutData(
RegionPosition.EAST);
regionEst.setSplit(true);
 
final BorderLayoutData regionOuest = new BorderLayoutData(
RegionPosition.WEST);
regionOuest.setSplit(true);
panneauPrincipalImage.setSize(cMediateur.getPanneauPrincipalCarnetEnLigne().getWidth(), cMediateur.getPanneauPrincipalCarnetEnLigne().getHeight()) ;
panneauPrincipalImage.setLayout(new BorderLayout()) ;
 
// on crée un modèle
iModele = ImageModele.Instance(this);
// et on demande l'arbre des mots clés
 
// on gère la mise en page du panneau principal
 
// on crée le panneau des filtres
filtres = new PanneauFiltresImagesVues(this);
filtres.setWidth("15%");
 
// le panneau à onglet qui contient les trois vues
ongletsImage = new TabPanel();
 
// la galerie
galerieImage = new GalerieImageVue(this);
 
// la liste des images
listeImage = new ListeImageVue(this);
listeImage.setTitle("Liste") ;
 
// le panneau zoom
zoomImage = new ZoomImageVue(this);
 
// on ajoute les panneaux au panneau à onglets
ongletsImage.add(galerieImage);
ongletsImage.add(listeImage);
ongletsImage.add(zoomImage);
 
// on crée les menu et la barre de vue
menuImageVue = new MenuImageVue(this);
barreOutilsVue = new BarreOutilsVue(this);
 
// on initialise le volet qui contient les mots clés
detailsEtMotsCles.setWidth("15%");
detailsEtMotsCles.setAnimCollapse(true);
detailsEtMotsCles.setTitleCollapse(true);
detailsEtMotsCles.setCollapsible(true);
 
// on crée le panneau conteneur des métadonnées et infos
metadonneesIptcExif = new PanneauMetadonneesVue(this);
// et on l'inclut dans le volet approprié
detailsEtMotsCles.add(metadonneesIptcExif);
panneauMenuEtOngletsImage = new Panel() ;
panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ;
// on ajoute la barre de vue au nord du panneau qui contient menu et
// onglets d'images
panneauMenuEtOngletsImage.add(barreOutilsVue, regionNord);
// les onglets au centre
panneauMenuEtOngletsImage.add(ongletsImage, regionCentre);
// et le panneau de métadonnées et d'info sur le coté droit
panneauPrincipalImage.add(detailsEtMotsCles, regionEst);
// on ajoute le panneau qui contient le menu et les onglets d'images au
// centre
panneauPrincipalImage.add(panneauMenuEtOngletsImage, regionCentre);
// on ajoute les filtres au panneau gauche
panneauPrincipalImage.add(filtres,regionOuest) ;
detailsEtMotsCles.addListener(new ContainerListenerAdapter() {
 
public void onResize(BoxComponent component,int adjWidth,int adjHeight,int rawWidth,int rawHeight)
{
if(detailsEtMotsCles != null && detailsEtMotsCles.isRendered() && metadonneesIptcExif != null && metadonneesIptcExif.isRendered()) {
metadonneesIptcExif.doLayout();
}
}
});
// filtres.setCollapsed(false) ;
thisMediateur = this ;
estInitialise = true ;
changerUtilisateur() ;
}
 
/**
* Renvoie l'identifiant de l'utilisateur en cours
*
* @return l'identifiant de l'utilisateur
*/
public String getIdentifiant() {
return cMediateur.getUtilisateur().getIdentite();
}
 
/**
* . Setteur pour l'identifiant de l'utilisateur en cours
*
* @param id
* le nouvel identifiant utilisateur
*/
public void setIdentifiant(String id) {
identifiant = id;
}
 
/**
* Appelle les fonctions de chargement de données, suit généralement un
* appel à setIdentifiant, pour obtenir l'arbre des mots clés et les images
* du nouvel utilisateur
*/
public void changerUtilisateur() {
getIModele().initialiserArbreMotsCles();
obtenirPhotoGalerie(getGalerieImage());
}
 
/**
* Accesseur pour le modèle associé au médiateur
*
* @return le modèle associé
*/
public ImageModele getIModele() {
return iModele;
}
 
/**
* Accesseur pour le panneau principal
*
* @return le panneau principal
*/
public Panel getPanneauPrincipalImage() {
return panneauPrincipalImage;
}
 
/**
* Accesseur pour le panneau à onglets
*
* @return le panneau à onglets
*/
public TabPanel getOngletsImage() {
return ongletsImage;
}
 
/**
* Accesseur pour la galerie d'images
*
* @return la galerie d'image
*/
public GalerieImageVue getGalerieImage() {
return galerieImage;
}
 
public ListeImageVue getListeImage() {
return listeImage;
}
 
/**
* Accesseur pour le panneau "zoom"
*
* @return le panneau zoom
*/
public ZoomImageVue getZoomImage() {
return zoomImage;
}
 
/**
* Accesseur pour le panneau détails et mot clés
*
* @return le panneau détails et mots clés
*/
public Panel getDetailsEtMotsCles() {
return detailsEtMotsCles;
}
 
/**
* Accesseur pour le booleen d'instanciation
*
* @return le booleen d'instanciation
*/
public static boolean isEstInstancie() {
return estInstancie;
}
 
/**
* Accesseur pour la panneau contenant le menu et les onglets images
*
* @return le panneauMenuEtOngletsImage
*/
public Panel getPanneauMenuEtOngletsImage() {
return panneauMenuEtOngletsImage;
}
 
/**
* Accesseur pour le menu image
*
* @return the menuImageVue
*/
public MenuImageVue getMenuImageVue() {
return menuImageVue;
}
 
/**
* Accesseur pour la barre d'outils
*
* @return the barreOutilsVue
*/
public BarreOutilsVue getBarreOutilsVue() {
return barreOutilsVue;
}
 
/**
* Accesseur pour le panneau infos et métadonnées
*
* @return the metadonneesIptcExif
*/
public PanneauMetadonneesVue getMetadonneesIptcExif() {
return metadonneesIptcExif;
}
 
/**
* Renvoie l'index du dernier onglet sélectionné
*
* @return l'index du dernier onglet
*/
public int getDernierIndexOnglet() {
return dernierIndexOnglet;
}
 
 
/**
* Accesseur pour la barre de recherche
*
* @return la barre de recherche pour filtrer les commentaires
*/
public BarreRechercheFiltreVue getFiltreCommentaires() {
return filtreCommentaires;
}
 
/**
* Renvoie la vue sélectionné par l'utilisateur
*
* @return la vue selectionnée par l'utilisateur
*/
public VueListable getVueSelectionnee() {
Panel active = ongletsImage.getActiveTab();
if (active != zoomImage) {
if (active == galerieImage) {
return galerieImage;
} else {
return listeImage;
}
 
} else {
if (dernierIndexOnglet == 0) {
return galerieImage;
} else {
return listeImage;
}
 
}
 
}
 
/**
* Renvoie l'identifiant de la vue en cours
*
* @return l'identifiant de la vue en cours de visualisation
*/
public String getIdVueSelectionnee() {
Panel active = ongletsImage.getActiveTab();
if (active != zoomImage) {
if (active == galerieImage) {
return galerieImage.getId();
} else {
return listeImage.getId();
}
 
} else {
if (dernierIndexOnglet == 0) {
return galerieImage.getId();
} else {
return listeImage.getId();
}
 
}
 
}
 
/**
* 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) {
 
if (o instanceof Store) {
 
Store li = (Store) o;
 
if (li.getCount() <= 0) {
aucuneSelection();
} else {
selection();
}
 
}
 
if (r != getGalerieImage()) {
getGalerieImage().rafraichir(o, false);
}
if (r != getZoomImage()) {
getZoomImage().rafraichir(o, false);
}
if (r != getListeImage()) {
getListeImage().rafraichir(o, false);
}
 
aucuneSelection();
demasquerChargement();
}
 
/**
* envoie au modèle une demande de mise a jour
*
* @param r
* la vue demandeuse de mise a jour
*/
public void obtenirPhotoGalerie(Rafraichissable r) {
masquerChargement();
getIModele().obtenirNombrePhotoGalerie(r);
}
 
/**
* 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) {
getIModele().obtenirMetadonnees(r, id);
}
 
/**
* 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) {
getIModele().obtenirMotsClesId(r, id);
}
 
/**
* Envoie au modèle une demande pour obtenir l'arbre des mots clés
*
* @param r
* le raffraichissable qui a demandé la mise à jour
*/
public void obtenirArbreMotsCles(Rafraichissable r) {
getIModele().initialiserArbreMotsCles();
}
 
/**
* 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
*/
public void mettreAJourInfo(String commentaires, String date, String note) {
String ids[] = getVueSelectionnee().getIdSelectionnees();
 
getIModele().mettreAJourCacheImage(commentaires, date, note, ids);
getListeImage().mettreAjourInfos(commentaires, date, note);
}
 
/**
* Met à jour l'arbre des mots clés affichés dans le volet de droite à
* partir de l'arbre passé en paramètre
*
* @param arbreMC
* le nouvel arbre des mots clés
*/
public void rafraichirArbreMotsCles(Tree arbreMC) {
metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false);
filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
}
 
/**
* envoie au modèle une demande pour lancer le formulaire ou l'application
* d'upload
*/
public void uploaderImages(boolean multiple) {
if(cMediateur.getUtilisateur().isIdentifie()) {
getIModele().uploaderImages(multiple);
}
else
{
if(Window.confirm("L'envoi d'images nécéssite d'être identifié. Voulez-vous vous identifier maintenant ?")) {
cMediateur.afficherDialogueConnexion();
}
else
{
}
}
}
 
/**
* Envoie une demande au modèle pour obtenir toutes les données annexes de
* l'image (métadonnées, note, etc ...), on y centralise tous les appels a
* obtenirQuelqueChose
*
* @param imgNum
* l'identifiant de l'image
*/
public void obtenirDonnes(String imgNum) {
if(imgNum == null) {
return;
}
// si on est en mode liaison, on demande la liste des obs
if(getMetadonneesIptcExif().getMiniListeObservation().getMode())
{
obtenirObservationsAssociees() ;
}
obtenirMetadonnees(metadonneesIptcExif, imgNum);
obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), imgNum);
obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum);
 
}
public void changerModeLiaison(boolean mode) {
if(mode) {
obtenirObservationsAssociees() ;
metadonneesIptcExif.getRechercheFiltreTaxonVue().disable();
}
else {
obtenirNombreMiniListeObservations() ;
metadonneesIptcExif.getRechercheFiltreTaxonVue().enable();
}
}
 
/**
* Envoie une demande au modèle pour obtenir la note associée à une image
*
* @param noteVue
* le rafraichissable à qui est destiné cette information
* @param imgNum
* l'identifiant de l'image
*/
private void obtenirNote(Rafraichissable r, String imgNum) {
 
getIModele().obtenirNote(r, imgNum);
}
 
/**
* est appelé lors d'un clic de souris sur une vignette dans la galerie le
* médiateur gère alors les conséquences
*
* @param index
* l'index du noeud dans la galerie
* @param node
* le noeud selectionné
* @param e
* l'object source de l'évenement
*/
public void clicGalerieImage(int index, Element node, EventObject e) {
Record rd = getGalerieImage().getDView().getRecord(node);
String imgUrl = rd.getAsString("url_image");
String imgNum = rd.getAsString("num_image");
String imgTaxon = rd.getAsString("obs_associees");
String[] imgXY = getIModele().obtenirTailleImage(
rd.getAsString("num_image"));
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon};
 
getZoomImage().rafraichir(infosImage, false);
dernierIndexOnglet = 0;
 
if (DOM.eventGetType(e.getBrowserEvent()) == Event.ONDBLCLICK) {
 
getOngletsImage().setActiveTab(2);
}
 
obtenirDonnes(imgNum);
 
}
 
/**
* est appelé lors d'un clic de souris sur un enregistrement de la liste le
* médiateur gère alors les conséquences
*
* @param rowIndex
* le numéro de ligne selectionné
*/
public void clicListeImage(int rowIndex) {
Record rd = getListeImage().getSelectionModel().getSelected();
String imgUrl = rd.getAsString("url_image");
String imgNum = rd.getAsString("num_image");
String imgTaxon = rd.getAsString("obs_associees");
String[] imgXY = getIModele().obtenirTailleImage(
rd.getAsString("num_image"));
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon };
 
getZoomImage().rafraichir(infosImage, false);
dernierIndexOnglet = 1;
 
obtenirDonnes(imgNum);
}
 
/**
* gestion du double clic dans la liste
*
* @param rowIndex
*/
public void doubleClicListeImage(int rowIndex) {
getOngletsImage().setActiveTab(2);
}
 
/**
* envoie une demande de mise a jour des données au modèle
*/
public void rafraichirToutesVues() {
obtenirPhotoGalerie(getIModele());
}
 
/**
* montre le menu au coordonnées indiquées
*
* @param e
* l'objet source de l'évenement
*/
public void montrerContextMenu(EventObject e) {
menuImageVue.showAt(e.getXY());
}
/**
* montre le menu au coordonnées indiquées
*
* @param e
* l'objet source de l'évenement
*/
public void montrerContextMenu(int[] XY) {
menuImageVue.showAt(XY);
}
/**
* appelé lors du double clic sur l'image agrandie
*/
public void doubleClicZoomImage() {
getOngletsImage().setActiveTab(dernierIndexOnglet);
}
 
/**
* appelé lors du clic sur un des boutons de la zone zoom
*
* @param arg
* le nom du bouton qui a cliqué
*/
public void clicBoutonZoomImage(String arg) {
 
Store st;
int selected;
int storeIndex;
Record nRec = null;
 
// tout d'abord on obtient les index selectionnés suivant la vue
if (getVueSelectionnee() == galerieImage) {
DataView dv = getGalerieImage().getDView();
st = getGalerieImage().getSt();
 
if (st.getCount() <= 0) {
return;
}
 
selected = st.indexOf(dv.getSelectedRecords()[0]);
storeIndex = dv.indexOf(selected);
} else {
st = listeImage.getSt();
 
if (st.getCount() <= 0) {
return;
}
 
selected = st.indexOf(listeImage.getSelectionModel().getSelected());
storeIndex = selected;
}
 
if (arg.equals("prev")) {
// si la photo séléctionnée est la première, on passe a la
// dernière
if (selected == 0) {
storeIndex = st.getCount() - 1;
nRec = st.getAt(storeIndex);
 
} else {
storeIndex = storeIndex - 1;
nRec = st.getAt(storeIndex);
}
 
}
 
if (arg.equals("suiv")) {
// si la photo selectionnée est la dernière on passe a la
// première
if (selected == st.getCount() - 1) {
 
storeIndex = 0;
nRec = st.getAt(0);
} else {
storeIndex = storeIndex + 1;
nRec = st.getAt(storeIndex);
}
}
 
if (nRec != null) {
String imgUrl = nRec.getAsString("url_image");
String imgNum = nRec.getAsString("num_image");
String[] imgXY = getIModele().obtenirTailleImage(
nRec.getAsString("num_image"));
String imgTaxon = nRec.getAsString("obs_associees");
String[] infosImage = { imgUrl, imgXY[0], imgXY[1], imgNum, imgTaxon };
getZoomImage().rafraichir(infosImage, false);
 
if (getGalerieImage().isRendered()) {
getGalerieImage().getDView().select(storeIndex);
}
 
if (getListeImage().isRendered()) {
getListeImage().getSelectionModel().selectRecords(nRec);
}
 
obtenirDonnes(imgNum);
}
}
 
/**
* synchronise la selection entre la galerie et la liste
*
* @param string
* le nom de la vue qui doit être synchronisee
*/
public void synchroniserSelection(String string) {
 
if (string.equals("galerie") && getDernierIndexOnglet() != 2) {
Record[] sel = getGalerieImage().getDView().getSelectedRecords();
getListeImage().selectionnerEnregistrements(sel);
}
 
if (string.equals("liste") && getDernierIndexOnglet() != 0) {
 
Record[] sel = getListeImage().getSelectionModel().getSelections();
int[] ids = new int[sel.length];
 
for (int i = 0; i < sel.length; i++) {
 
ids[i] = getGalerieImage().getSt().indexOf(sel[i]);
}
 
getGalerieImage().selectionnerImages(ids);
}
 
}
 
/**
* fait une demande de suppression des images (en local et en distant) des
* images selectionnees
*/
public void supprimerImages() {
 
String[] ids = null;
 
if (dernierIndexOnglet == 0) {
ids = getGalerieImage().getIdSelectionnees();
} else {
ids = getListeImage().getIdSelectionnees();
}
 
if (ids.length > 0) {
 
if (com.google.gwt.user.client.Window
.confirm("Supprimer les images selectionnees ?")) {
masquerChargement();
getIModele().supprimerImages(ids);
aucuneSelection();
}
} else {
Window.alert("Impossible de supprimer : aucune image selectionnee");
}
 
}
 
/**
* desactive les onglets de metadonnees et de zoom (dans le cas ou rien
* n'est selectionne)
*/
public void aucuneSelection() {
 
if (getListeImage().getSelectionModel().getCount() <= 0
&& getGalerieImage().getDView().getSelectionCount() <= 0) {
getZoomImage().disable();
getMetadonneesIptcExif().desactiverPanneau();
getZoomImage().desactiverPanneau();
setSelection(false);
}
 
}
 
/**
* reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il
* n'y en avait pas)
*/
public void selection() {
 
if (!isSelection()) {
getMetadonneesIptcExif().activerPanneau();
getZoomImage().activerPanneau();
getZoomImage().enable();
setSelection(true);
}
}
 
/**
* Fait apparaitre le menu contextuel de l'arbre des mots clés au niveau
* d'un noeud donné
*
* @param n
* le noeud ou le menu doit apparaitre
* @param ev
* l'objet contenant les données sur l'évenement
* @param te
* l'éditeur associé à l'arbre qui permet de modifier les
* libellés des noeuds
*/
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 cle");
final com.gwtext.client.widgets.menu.Item suppN = new Item(
"Supprimer mot cle");
 
mn.addItem(ajoutN);
mn.addItem(suppN);
 
mn.addListener(new MenuListenerAdapter() {
 
public void onItemClick(BaseItem item, EventObject e) {
if (item.equals(suppN)) {
getMetadonneesIptcExif().getPanneauMotsCles()
.supprimerNoeud(n);
}
if (item.equals(ajoutN)) {
getMetadonneesIptcExif().getPanneauMotsCles().ajouterNoeud(
n);
}
}
});
 
mn.showAt(ev.getXY());
 
}
 
/**
* Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du
* mot clé
*
* @param text
* le texte du mot clé
* @param id
* l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id) {
 
getIModele().mettreAjourMotsClesId(text, id);
 
}
 
/**
* Récupère les identifiants des images selectionnés et appelle le modèle
* pour qu'il mette à jour les associations mots clés/images
*
* @param motsClesEnCours
* les mots clés à associer aux images selectionnés séparés par
* une ','
* @param arbreMC
* l'arbre des mots clés à mettre à jour
*/
public void mettreAjourMotsCles(String motsClesEnCours, Tree arbreMC) {
 
String[] ids = getGalerieImage().getIdSelectionnees();
getIModele().mettreAjourMotsCles(ids, motsClesEnCours, arbreMC);
 
}
 
/**
* Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots
* clés
*
* @param n
* le noeud à ajouter à l'arbre
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
getIModele().ajouterMotCleDansArbre(n, arbreMC);
filtres.getMotsClesFiltre().rafraichir(n, false);
 
}
 
/**
* Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre
* dans l'arbre des mots clés
*
* @param n
* le noeud à supprimer
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
getIModele().supprimerMotCleDansArbre(n, arbreMC);
filtres.getMotsClesFiltre().rafraichir(n.getId(), false);
 
}
 
/**
* Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots
* clés
*
* @param n
* le noeud à modifier
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
getIModele().modifierMotCleDansArbre(n, arbreMC);
filtres.getMotsClesFiltre().rafraichir(n, false);
 
}
 
/**
* Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans
* l'arbre des mots clés
*
* @param n
* le noeud à déplacer
* @param arbreMC
* le nouvel arbre de mots clés à mettre à jour
*/
public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
getIModele().deplacerMotCleDansArbre(n, arbreMC);
filtres.getMotsClesFiltre().rafraichir(n, false);
}
 
/**
* initialise les mots clés cochés par rapport aux images sélectionnées
*/
public void initialiserMotsCleCoches() {
 
obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(),
getGalerieImage().getIdSelectionnees()[0]);
}
 
/**
* Appelle le modèle pour lui demander les données d'une page à afficher
*
* @param pageCourante
* le numéro de page à affciher
*/
public void changerNumeroPage(int pageCourante) {
 
// on met le mesage d'attente
masquerChargement();
 
// on appelle le modèle
getIModele().changerNumeroPage(pageCourante);
 
// et met à jour les numéros de page dans les barre d'outils
getGalerieImage().getToolBarVue().changerPageCourante(pageCourante);
getListeImage().getToolBarVue().changerPageCourante(pageCourante);
}
 
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
*
* @param nouvelleTaillePage
* la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage) {
// on met le message d'attente
masquerChargement();
 
// on appelle le modèle
getIModele().changerTaillePage(nouvelleTaillePage);
 
// et on met à jour la taille de page dans les barres d'outils
getGalerieImage().getToolBarVue().selectionnerTaillePage(
nouvelleTaillePage);
getListeImage().getToolBarVue().selectionnerTaillePage(
nouvelleTaillePage);
}
 
/**
* Met à jour les barre d'outils avec des nouvelles valeurs
*
* @param pageMax
* le nombre de pages
* @param pageEncours
* la page en cours
* @param taillePage
* la taille de page
* @param nbElement
* le nombre d'élements par page
*/
public void changerPageMaxEtCourante(int pageMax, int pageEncours,
int taillePage, int nbElement) {
 
int[] pages = { pageMax, pageEncours, taillePage, nbElement };
getGalerieImage().getToolBarVue().rafraichir(pages, false);
getListeImage().getToolBarVue().rafraichir(pages, false);
 
}
 
/**
* Recherche l'élement actuellement affiché et affiche son message de
* chargement
*/
public void masquerChargement() {
if(GWT.isScript()) {
ExtElement masked = Ext.get(getIdVueSelectionnee());
if (masked != null && !masked.isMasked()) {
masked.mask("Chargement", true);
}
}
}
 
/**
* Recherche l'élement actuellement affiché et retire son message de
* chargement si l'était affiché
*/
public void demasquerChargement() {
if(GWT.isScript()) {
ExtElement masked = Ext.get(getIdVueSelectionnee());
if (masked != null && masked.isMasked()) {
masked.unmask();
}
}
}
 
public void afficherMenuId() {
IdVue i = new IdVue(this);
i.show();
}
 
/**
* C'est dans cette fonction que doivent être renvoyé les valeurs des
* filtres sous forme de tableau [nom, valeur]
*
* @return Les noms et valeurs des filtres
*/
public String[][] renvoyerFiltres() {
String[][] valeursFiltres = filtres.renvoyerValeursAFiltrer();
 
return valeursFiltres;
}
 
/**
* Indique si les filtres ont changés depuis la dernière requête (il faut
* faire un OR sur le résultat de toutes les fonctions renvoyerEtatFiltre
* s'il y a plus d'un filtre)
*
* @return true si au moins un des filtres a changé, false sinon
*/
public boolean getEtatFiltres() {
return (filtres.renvoyerEtatFiltre());
}
 
/**
* Accesseur pour le panneau de droite contenant les filtres
*
* @return le panneau contenant les filtres
*/
public PanneauFiltresImagesVues getPanneauFiltres() {
return filtres;
}
 
/**
* ajoute les images séléctionnées dans la vue courante au tampon
*/
public void ajouterImagesSelection() {
String[] ids = getVueSelectionnee().getIdSelectionnees();
String id = "";
for (int i = 0; i < ids.length; i++) {
id += " - " + ids[i];
}
getIModele().ajouterImagesSelection(ids);
 
Window.alert(ids.length + " image(s) ajoutées au tampon ");
 
}
/**
* Affiche les ids des images contenues dans le tampon
*/
public void afficherIdSelectionImages() {
 
Window.alert("Contenu du tampon : " + getIModele().renvoyerSelection());
 
}
/**
* Renvoie les ids des images contenues dans le tampon en une seule string
* @return une string de la forme id1, id2, id3
*/
public String renvoyerSelection() {
return getIModele().renvoyerSelection();
}
/**
* Vide le tampon d'images
*/
public void viderSelection() {
 
getIModele().viderSelection();
Window.alert("Le tampon a été vidé ");
 
}
public int getCompteSelection() {
return getIModele().getCompteSelection();
}
 
/**
* Fonction appelée lors du drag 'n drop d'une image sur une observation
* @param source la source du drag
* @param e l'objet sur lequel on a fait le drop
* @param data les données
* @return une booleen indiquant le succès ou l'échec de l'opération
*/
public boolean lierImagesDD(DragSource source, EventObject e, DragData data) {
// on peut convertir directement les données car on a testé avant le type de données
GridDragData gdd = (GridDragData)data ;
// les ids des images sont initialisées
String idsImg = "" ;
// on obtient la liste des selections dans la source
Record[] aLier = gdd.getSelections() ;
for (int i = 0; i < aLier.length; i++)
{
// on les concatènes en une seule chaine
idsImg += aLier[i].getAsString("id_image")+"," ;
}
MiniListeObservationVue mv = getMetadonneesIptcExif().getMiniListeObservation() ;
// on cherche quel est la ligne sur laquelle on a fait le drop dans la la liste des observations
int index = mv.getView().findRowIndex(e) ;
Record rddrop = mv.getStore().getRecordAt(index) ;
// SI l'enregistrement existe bel et bien
if(rddrop != null)
{
String idObss = "";
Record[] selection = mv.getSelectionModel().getSelections();
boolean lierSelection = false;
// on itère sur toutes les observations selectionnées
for(int i=0; i<selection.length && lierSelection == false; i++) {
// si l'element sur lequel on a fait le drop fait partie
// de la selection alors on lie tout à la selection
if(selection[i].getId() == rddrop.getId()) {
lierSelection = true;
}
// si l'élement ne fait pas partie de la selection
//alors on ne lit qu'à celui sur lequel on a fait le drop
idObss += selection[i].getAsString("id_obs")+"," ;
}
String message = "";
if(!lierSelection) {
idObss = rddrop.getAsString("id_obs")+",";
message = "Lier la selection d'images à l'observation pointée ?";
} else {
message = "Lier la selection d'images aux observations selectionnées ?";
}
if(Window.confirm(message)) {
lierImagesObservation(idObss, idsImg) ;
}
}
return true ;
}
/**
* Fonction appelée lors du drag 'n drop d'une observation sur une image
* @param source la source du drag
* @param e l'objet sur lequel on a fait le drop
* @param data les données
* @return une booleen indiquant le succès ou l'échec de l'opération
*/
public boolean lierObsDD(DragSource source, EventObject e, DragData data, String idDest) {
// on peut convertir directement les données car on a testé avant le type de données
GridDragData gdd = (GridDragData)data ;
// les ids des images sont initialisées
String idsObs = "" ;
// on obtient la liste des selections dans la source
Record[] aLier = gdd.getSelections() ;
for (int i = 0; i < aLier.length; i++)
{
// on les concatènes en une seule chaine
idsObs += aLier[i].getAsString("id_obs")+"," ;
}
Record rddrop = null ;
int index = -1;
// si la destination est la galerie d'images
if(idDest.equals(getGalerieImage().getId()))
{
GalerieImageVue gv = getGalerieImage() ;
// alors l'élément sur lequel on a fait le drop n'est pas le bon
index = gv.getDView().indexOf(e.getTarget()) ;
Element el = e.getTarget() ;
// alors on cherche son parent tant que celui-ci n'est pas présent dans la dataview
while(index == -1 && el != null)
{
index = gv.getDView().indexOf(el) ;
el = (Element) el.getParentElement() ;
}
// si on l'a trouvé, on obtient l'enregistrement qui correspond
if(index != -1)
{
rddrop = gv.getSt().getAt(index) ;
}
}
// si la destination est la liste d'images
if(idDest.equals(getListeImage().getId()))
{
// on obtient directement l'enregistrement correspondant à l'élément sur lequel on a fait le drop
ListeImageVue lv = getListeImage() ;
index = lv.getView().findRowIndex(e) ;
rddrop = lv.getSt().getAt(index) ;
}
// si on a bien obtenu un enregistrement
if(rddrop != null)
{
String idImgs = "";
Record[] selection = galerieImage.getDView().getSelectedRecords();
boolean lierSelection = false;
String message = "";
// si l'element sur lequel on a fait le drop fait partie
// de la selection alors on lie tout à la selection
if(galerieImage.getDView().isSelected(index)) {
lierSelection = true;
// on itère sur toutes les images selectionnées
for(int i=0; i<selection.length; i++) {
// et on récupère leur ids
idImgs += selection[i].getAsString("id_image")+"," ;
}
}
if(!lierSelection) {
idImgs = rddrop.getAsString("id_image")+",";
message = "Lier la selection d'observations à l'image pointée ?";
} else {
message = "Lier la selection d'observations aux images selectionnées ?";
}
if(Window.confirm(message)) {
lierImagesObservation(idsObs, idImgs) ;
}
return true ;
}
// si la destination est l'image zoomée
if(idDest.equals(getZoomImage().getId()))
{
// on obtient directement l'id correspondant
ZoomImageVue zv = getZoomImage() ;
String idImg = zv.getIdImage() ;
lierImagesObservation(idsObs, idImg) ;
return true ;
}
return false ;
}
public void LierTamponObservations() {
Record[] obsRec = getMetadonneesIptcExif().getMiniListeObservation().getSelectionModel().getSelections() ;
String idsObs = "" ;
for(int i =0 ; i< obsRec.length ; i++)
{
idsObs += obsRec[i].getAsString("id_obs")+"," ;
}
if(getIModele().renvoyerSelection().equals("-255"))
{
Window.alert("Le tampon est vide") ;
return ;
}
if(obsRec.length == 0)
{
Window.alert("Aucune(s) observation(s) selectionnée(s)") ;
return ;
}
else
{
lierImagesObservation(idsObs, getIModele().renvoyerSelection()) ;
}
}
public void LierObservations() {
Record[] obsRec = getMetadonneesIptcExif().getMiniListeObservation().getSelectionModel().getSelections() ;
String idsObs = "" ;
String[] idsImg = getGalerieImage().getIdSelectionnees();
String selectionImages = "";
if(idsImg.length <= 0)
{
Window.alert("Aucune image selectionnée") ;
return ;
} else {
for (int i = 0; i < idsImg.length; i++) {
String idEncours = idsImg[i];
selectionImages += idEncours + ",";
}
}
if(obsRec.length == 0)
{
Window.alert("Aucune(s) observation(s) selectionnée(s)") ;
return ;
} else {
for(int i =0 ; i< obsRec.length ; i++)
{
idsObs += obsRec[i].getAsString("id_obs")+"," ;
}
}
String message = "Lier la selection d'images aux observations selectionnées ?";
if(Window.confirm(message)) {
lierImagesObservation(idsObs, selectionImages) ;
}
}
/**
* Lie une ou plusieurs images à une ou plusieurs observations
* @param idsObs les identifiants des observations séparés par des ","
* @param idsImg les identifiants des images séparés par des ","
*/
public void lierImagesObservation(String idsObs, String idsImg)
{
getIModele().lierImagesObervations(idsObs,idsImg) ;
}
 
public void deconnecterUtilisateur() {
if(panneauPrincipalImage.isVisible())
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiant()) ;
changerUtilisateur() ;
}
else
{
panneauPrincipalImage.addListener(new ContainerListenerAdapter()
{
public void onRender(Component component)
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiant()) ;
changerUtilisateur() ;
panneauPrincipalImage.purgeListeners() ;
}
}) ;
}
}
public void connecterUtilisateur() {
if(panneauPrincipalImage.isVisible()) {
setIdentifiant(cMediateur.getUtilisateur().getIdentifiant());
getIModele().initialiserArbreMotsCles();
obtenirPhotoGalerie(getGalerieImage());
}
else
{
if(this.iModele != null) {
panneauPrincipalImage.addListener(new ContainerListenerAdapter()
{
public void onShow(Component c)
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiant());
getIModele().initialiserArbreMotsCles();
obtenirPhotoGalerie(getGalerieImage());
panneauPrincipalImage.purgeListeners() ;
}
}) ;
}
else
{
panneauPrincipalImage.addListener(new ContainerListenerAdapter()
{
public void onRender(Component c)
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiant());
getIModele().initialiserArbreMotsCles();
obtenirPhotoGalerie(getGalerieImage());
panneauPrincipalImage.purgeListeners() ;
}
}) ;
}
}
}
public String[] renvoyerFiltresObservation() {
String[] rien = {"nom_taxon",""};
if(getMetadonneesIptcExif() != null) {
return getMetadonneesIptcExif().getRechercheFiltreTaxonVue().renvoyerValeursAFiltrer();
} else {
return rien;
}
}
public void obtenirNombreMiniListeObservations(
Rafraichissable r) {
iModele.obtenirNombreMiniListeObservations(r, renvoyerFiltresObservation());
}
 
public void obtenirNombreMiniListeObservations() {
iModele.obtenirNombreMiniListeObservations(getMetadonneesIptcExif().getMiniListeObservation(), renvoyerFiltresObservation());
}
 
public void obtenirMiniListeObservations(
Rafraichissable r, int taillePage, int numeroPage) {
iModele.obtenirMiniListeObservations(r, renvoyerFiltresObservation(), taillePage, numeroPage) ;
}
 
public void afficherAide() {
String aideUrl = Configuration.getAideBaseUrl() ;
Window.open(aideUrl, "", "") ;
}
 
public void soumettreBugRemarque() {
String suiviUrl = Configuration.getSuiviBugUrl() ;
Window.open(suiviUrl, "", "") ;
}
 
public void obtenirObservationsAssociees() {
String ids[] = getVueSelectionnee().getIdSelectionnees() ;
if(ids.length > 0) {
getMetadonneesIptcExif().getMiniListeObservation().masquerChargement() ;
getIModele().obtenirLiaisonObservations(this,ids[0]);
}
}
public void rafraichirMiniListeObservations(ListeObservation listeObs) {
if(getMetadonneesIptcExif() != null && getMetadonneesIptcExif().isCreated()) {
if(getMetadonneesIptcExif().getMiniListeObservation().isCreated())
{
getMetadonneesIptcExif().getMiniListeObservation().rafraichir(listeObs, false) ;
}
}
}
 
public void supprimerLiaisonObsImage() {
 
String idsImg[] = getVueSelectionnee().getIdSelectionnees() ;
String idObs = getMetadonneesIptcExif().getMiniListeObservation().getIdSelectionnees() ;
if(Window.confirm("Supprimer le lien entre image(s) et observation(s) ?"))
{
getMetadonneesIptcExif().getMiniListeObservation().supprimerLiaison() ;
iModele.supprimerLiaisonImages(idsImg,idObs) ;
}
}
public boolean estInstancie() {
return estInstancie ;
}
 
public void donneesExterieures(Object o) {
if(estInitialise) {
iModele.rafraichir(o, true);
}
}
}