Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 2457 → Rev 2470

/branches/v2.8-houe/src/org/tela_botanica/client/image/ImageMediateur.java
New file
0,0 → 1,1820
package org.tela_botanica.client.image;
 
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.cel2;
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.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.vues.image.BarreOutilsVue;
import org.tela_botanica.client.vues.image.FenetreGestionMotsCles;
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.PanneauMetadonneesVue;
import org.tela_botanica.client.vues.image.ZoomImageVue;
import org.tela_botanica.client.vues.image.filtres.BarreRechercheFiltreVue;
import org.tela_botanica.client.vues.image.filtres.PanneauFiltresImagesVues;
 
import com.google.gwt.core.client.GWT;
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.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.DataView;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
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.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;
/**
* Fenetre modale de gestion des mots clés
*/
private FenetreGestionMotsCles fnMc = 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() {
@Override
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);
 
// 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() {
 
@Override
public void onResize(BoxComponent component,int adjWidth,int adjHeight,int rawWidth,int rawHeight)
{
if(detailsEtMotsCles != null && detailsEtMotsCles.isRendered() && metadonneesIptcExif != null && metadonneesIptcExif.isRendered()) {
metadonneesIptcExif.doLayout();
}
}
});
creerPanneauGestionMotsCles();
// 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().getIdentifiantUtilisateurConsulte();
}
 
/**
* . 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();
if (ongletsImage.getActiveTab().getId() == getZoomImage().getId()) {
ongletsImage.activate(0);
}
} else {
selection();
}
 
if (r != getGalerieImage()) {
getGalerieImage().rafraichir(o, false);
}
if (r != getZoomImage()) {
getZoomImage().rafraichir(o, false);
}
if (r != getListeImage()) {
getListeImage().rafraichir(o, false);
}
 
demasquerChargement();
 
}
}
 
public void obtenirPhotoGalerie() {
obtenirPhotoGalerie(getGalerieImage());
}
 
/**
* 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);
}
 
public void obtenirMotsClesTexte(Rafraichissable r, String id) {
String[] texteMotsCles = getTexteMotsCles(getIModele().getMotsClesId(id));
r.rafraichir(texteMotsCles, false);
}
//TODO: devrait être dans le modèle
public String[] getTexteMotsCles(String idsMotsCles[]) {
String[] tableauMotsClesTexte = new String[idsMotsCles.length];
for(int i=0; i< idsMotsCles.length; i++) {
tableauMotsClesTexte[i] = iModele.obtenirTexteMotCle(idsMotsCles[i]);
}
return tableauMotsClesTexte;
}
 
/**
* 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) {
rafraichirArbreMotsClesFiltre(arbreMC);
metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false);
if(fnMc != null) {
fnMc.rafraichir(arbreMC, false);
}
}
public void rafraichirArbreMotsClesFiltre(Tree arbreMc) {
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(metadonneesIptcExif.isVisible()) {
if(imgNum == null) {
return;
}
// si on est en mode liaison, on demande la liste des obs
if(getMetadonneesIptcExif().getMiniListeObservation().getMode())
{
obtenirObservationsAssociees() ;
}
obtenirMetadonnees(metadonneesIptcExif, imgNum);
obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), imgNum);
obtenirNote(metadonneesIptcExif.getNoteVue(), imgNum);
}
obtenirMotsClesId(fnMc, 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 renommerN = new Item(
"Renommer mot cle");
final com.gwtext.client.widgets.menu.Item suppN = new Item(
"Supprimer mot cle");
 
mn.addItem(ajoutN);
mn.addItem(renommerN);
mn.addItem(suppN);
 
mn.addListener(new MenuListenerAdapter() {
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
if (item.equals(suppN)) {
fnMc.supprimerNoeud(n);
}
if (item.equals(renommerN)) {
fnMc.renommerNoeud(n);
}
if (item.equals(ajoutN)) {
fnMc.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();
if(ids.length > 0) {
getIModele().mettreAjourMotsCles(ids, motsClesEnCours, arbreMC);
obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), ids[ids.length - 1]);
}
 
}
 
/**
* 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, Rafraichissable r) {
getIModele().ajouterMotCleDansArbre(n, arbreMC, r);
filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
mettreAJourListeMotsClesAffiches();
}
 
/**
* 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, Rafraichissable r) {
getIModele().supprimerMotCleDansArbre(n, arbreMC, r);
filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
mettreAJourListeMotsClesAffiches();
}
 
/**
* 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, Rafraichissable r) {
getIModele().modifierMotCleDansArbre(n, arbreMC, r);
getIModele().mettreAjourMotsClesId(n.getText(), n.getId());
filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
mettreAJourListeMotsClesAffiches();
}
 
/**
* 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, Rafraichissable r) {
getIModele().deplacerMotCleDansArbre(n, arbreMC, r);
filtres.getMotsClesFiltre().rafraichir(arbreMC, false);
mettreAJourListeMotsClesAffiches();
}
public void mettreAJourListeMotsClesAffiches() {
String[] ids = getGalerieImage().getIdSelectionnees();
if(ids.length > 0) {
obtenirMotsClesTexte(metadonneesIptcExif.getPanneauMotsCles(), ids[ids.length - 1]);
}
}
 
/**
* 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
*/
@Override
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
*/
@Override
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();
barreOutilsVue.setFiltresEnCours(valeursFiltres);
 
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;
}
/**
* Réinitialise tous les filtres en cours
*
*/
public void viderFiltres() {
filtres.viderFiltres();
obtenirPhotoGalerie();
}
/**
* Réinitialise un filtre en cours suivant le nom donné
*
* @param String le nom du filtre
*/
public void viderFiltre(String nom) {
filtres.viderFiltre(nom);
obtenirPhotoGalerie();
}
 
/**
* 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 = rddrop.getAsString("id_obs")+"," ;
String message = "";
idObss = rddrop.getAsString("id_obs")+",";
message = "Lier la selection d'images à l'observation selectionnée (ceci replacera les liaisons précédentes) ?";
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 (ceci replacera les liaisons précédentes) ?";
} else {
message = "Lier la selection d'observations aux images selectionnées (ceci replacera les liaisons précédentes) ?";
}
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 = iModele.obtenirIdPourOrdre(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 (ceci replacera les liaisons précédentes) ?";
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().getIdentifiantUtilisateurConnecte()) ;
changerUtilisateur() ;
}
else
{
panneauPrincipalImage.addListener(new ContainerListenerAdapter()
{
@Override
public void onRender(Component component)
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte()) ;
changerUtilisateur() ;
panneauPrincipalImage.purgeListeners() ;
}
}) ;
}
}
public void connecterUtilisateur() {
if(panneauPrincipalImage.isVisible()) {
setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte());
getIModele().initialiserArbreMotsCles();
filtres.getArbreDateRecherche().initialiser();
obtenirPhotoGalerie(getGalerieImage());
}
else
{
panneauPrincipalImage.addListener(new ContainerListenerAdapter()
{
@Override
public void onRender(Component c)
{
setIdentifiant(cMediateur.getUtilisateur().getIdentifiantUtilisateurConnecte());
getIModele().initialiserArbreMotsCles();
filtres.getArbreDateRecherche().initialiser();
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);
}
}
 
public void obtenirDatesImages(Rafraichissable r) {
iModele.obtenirDatesImages(r);
}
public void creerPanneauGestionMotsCles() {
fnMc = new FenetreGestionMotsCles() {
@Override
protected void surSuppressionMotCle(TreeNode node, Tree arbre) {
supprimerMotCleDansArbre(node, arbre, fnMc);
}
@Override
protected void surDeplacementMotCle(TreeNode node, Tree arbre) {
deplacerMotCleDansArbre(node, arbre, fnMc);
}
@Override
protected void surClicValider(String chaineMotsCles, Tree arbre) {
mettreAjourMotsCles(chaineMotsCles, arbre);
}
@Override
protected void surChangementTexte(TreeNode node, Tree arbre) {
modifierMotCleDansArbre(node, arbre, fnMc);
}
@Override
protected void surAjoutMotCle(TreeNode node, Tree arbre) {
ajouterMotCleDansArbre(node, arbre, fnMc);
}
@Override
protected void surAffichageMenuContextuel(TreeNode node, EventObject e,
TreeEditor te) {
montrerContextMenuArbre(node, e, te);
}
@Override
protected void demanderArbreMotsCles(Rafraichissable r) {
ImageMediateur.this.obtenirArbreMotsCles(r);
}
protected void surRetourWebService(Tree arbreMc) {
rafraichirArbreMotsClesFiltre(arbreMc);
}
};
fnMc.setModal(true);
fnMc.setHeight(420);
fnMc.setWidth(285);
fnMc.addListener(new WindowListenerAdapter() {
 
@Override
public void onClose(Panel panel) {
}
 
});
//fnMc.activerBoutonValider(selection);
}
 
public void afficherFenetreGestionMotsCles() {
fnMc.show();
String[] ids = getVueSelectionnee().getIdSelectionnees();
if(ids.length > 0) {
obtenirMotsClesId(fnMc, ids[ids.length - 1]);
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/image/ImageModele.java
New file
0,0 → 1,951
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.dao.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.user.client.Window;
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.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
* Modèle d'accès aux données pour les images. C'est un singleton
*
* @author aurelien
*
*/
public class ImageModele implements Rafraichissable {
 
/**
* Booleen indiquant si le médiateur est instancié (l'instance doit être
* unique donc le booleen est static)
*/
private static boolean estInstancie = false;
 
/**
* le modèle lui même
*/
private static ImageModele thisModele = null;
 
/**
* Le médiateur associé au modèle
*/
private ImageMediateur iMediateur = null;
 
/**
* La configuration en cours
*/
private Configuration config = 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<String, String> motsCles = new HashMap<String, String>(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;
 
/**
* "Presse papier" pour les images qui permet de garder en mémoire une
* sélection
*/
private Vector<String> selectionImages = new Vector<String>(0);
 
/**
* Retourne une instance de manière unique
*
* @param im
* le médiateur à associer
* @return l'instance du modèle
*/
static ImageModele Instance(ImageMediateur im) {
// si le modèle n'est pas encore instancié
if (!estInstancie) {
// on en crée un nouveau
estInstancie = true;
thisModele = new ImageModele(im);
}
 
// sinon on retourne le "pointeur" vers le modèle lui-même
return thisModele;
 
}
 
/**
* Le constructeur est privé et seule la méthode instance y accède
*
* @param im
* le médiateur à associer
*/
private ImageModele(ImageMediateur im) {
 
iMediateur = im;
config = new Configuration();
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Appelle le DAO asynchrone pour obtenir la liste des images
*
* @param r
* le rafraichissable auxquel on enverra les données
*/
public void obtenirNombrePhotoGalerie(Rafraichissable r) {
 
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
 
int tailleFiltres = valeursFiltres.length;
 
String[][] criteres = new String[tailleFiltres][2];
 
String[] utilisateur = {
"" + getIMediateur().getIdentifiant() };
criteres[0] = utilisateur;
 
 
for (int i = 0; i < valeursFiltres.length; i++) {
criteres[i] = valeursFiltres[i];
}
 
// on les crée un DAO auquel on les transmet et qui demande le nombre
// d'images correspondantes (pour les pages)
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
niaDAO.obtenirNombreImages(this, criteres);
}
public void obtenirPhotoGalerie(Rafraichissable r)
{
String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
int tailleFiltres = valeursFiltres.length;
String[][] criteres2 = new String[tailleFiltres + 2][2];
String[] limite = { "limite", "" + taillePage };
String[] taillePage = { "numero_page", "" + pageEncours };
criteres2[0] = limite;
criteres2[1] = taillePage;
 
for (int i = 0; i < valeursFiltres.length; i++) {
criteres2[i + 2] = valeursFiltres[i];
}
// et on crée un DAO auquel on les transmet et qui envoie une requete
// pour recevoir les images
ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
liaDAO.ObtenirListeImages(this, criteres2);
}
 
/**
* Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et
* lancer l'interface appropriée
*/
@SuppressWarnings("static-access")
public void uploaderImages(boolean multiple) {
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
if(multiple) {
IuADaO.appelerUploadMultiple();
}
else
{
IuADaO.appelerUploadSimple();
}
}
 
/**
* 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
*/
@SuppressWarnings("unchecked")
public void rafraichirMotsCles(Object o) {
if (o instanceof HashMap) {
motsCles = (HashMap<String, String>) 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 = 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) {
 
String[] motsClesIdTab = getMotsClesId(id);
r.rafraichir(motsClesIdTab, false);
}
public String[] getMotsClesId(String idImage) {
ImageCarnet im = cacheImage.get(idImage);
String motsClesId = im.getMotsCles();
String[] motsClesIdTab = motsClesId.split(",");
return motsClesIdTab;
}
/**
* Va chercher le nom du mot clé associé à un id dans le cache local
*
* @param String id
* id du mot clé
* @return le mot clé associé à l'identifiant
*/
public String obtenirTexteMotCle(String id) {
String correspondanceId = "";
String motCleTexte = motsCles.get(id);
if(motCleTexte != null) {
correspondanceId = motCleTexte;
}
return correspondanceId;
}
/**
* Construit une chaine contenant le texte des mots clés séparés par des virgules
*/
public String renvoyerChaineMotClesTexte(ImageCarnet ic) {
String chaineMotsCles = ic.getMotsCles();
String[] tabMotsCles = chaineMotsCles.split(",");
String chaineMotsClesTexte = "";
for (int i = 0; i < tabMotsCles.length; i++) {
chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);
chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";
}
return chaineMotsClesTexte;
}
 
/**
* Met à jour la liste des images en local et appelle le DAO de mise à jour
* pour les commentaires et la date des images selectionnées
*
* @param commentaires
* le commentaire à appliquer
* @param date
* la date à appliquer
* @param ids
* les identifiants des images selectionnées
*/
public void mettreAJourCacheImage(String commentaires, String date,
String note, String ids[]) {
for (int i = 0; i < ids.length; i++) {
String key = ids[i];
ImageCarnet ic = cacheImage.get(key);
ic.miseAJourInfoGenerales(commentaires, date, note);
mettreAjourBaseDeDonneesImageCarnet(ic);
}
 
}
 
/**
* Ajoute un nouveau mot clés à la liste des mots clés locale
*
* @param text
* le mot clé
* @param id
* l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id) {
motsCles.put(id, text);
}
 
/**
* Appelle le DAO chargé de mettre à jour la base de données avec les toutes
* les informations des images modifiées par l'utilisateur
*/
public void mettreAJourBaseDeDonneesListeImageCarnet() {
ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
 
liDaO.SynchroniserBaseDeDonnees(cacheImage);
}
 
/**
* Appelle le DAO chargé de mettre à jour la base de données avec les toutes
* les informations d'une image donnée
*
* @param ic
* l'image à synchroniser avec la base
*/
public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {
ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
iaDaO.SynchroniserBaseDeDonnees(ic);
}
 
/**
* Supprime les images données du cache local et appelle le DAO qui les
* supprime de la base de données
*
* @param ids
* les identifiants des images selectionnées
*/
public void supprimerImages(String[] ids) {
String rids[] = new String[ids.length];
ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
 
for (int i = 0; i < ids.length; i++) {
String key = ids[i];
ImageCarnet ic = 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
*/
@Override
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()][13];
int i = 0;
 
if (data.size() == 0) {
pageEncours = 0;
}
 
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
ImageCarnet im = data.get(it.next());
photoData[i][0] = im.getOrdre();
photoData[i][1] = im.getNomOriginal();
photoData[i][2] = im.getDate();
photoData[i][3] = im.getIptcCity();
photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();
photoData[i][5] = im.getUrlFormatListe();
photoData[i][6] = im.getUrlFormatGalerie();
photoData[i][7] = im.getUrlFormatZoom();
photoData[i][8] = im.getNote();
photoData[i][9] = im.getId();
photoData[i][10] = im.getTailleImage()[1];
photoData[i][11] = im.getTailleImage()[0];
photoData[i][12] = im.getIdsObsAssociees();
 
i++;
}
 
// creation du store qui les contient
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defNomImage = new StringFieldDef("nom_original");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new IntegerFieldDef("note_image");
FieldDef defIdImage = new IntegerFieldDef("id_image");
FieldDef defTailleX = new IntegerFieldDef("taille_x");
FieldDef defTailleY = new IntegerFieldDef("taille_y");
FieldDef defObsAssociees = new StringFieldDef("obs_associees");
FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage, defIdImage, defTailleX, defTailleY, defObsAssociees };
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 donneesArbre = (JSONArray)nouvelleDonnees;
Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Tags", "racine", donneesArbre, false);
arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
 
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
rafraichirArbreMotsCles(arbreMotsCles);
// la table de hachage
rafraichirMotsCles(motsCles);
// 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]);
obtenirPhotoGalerie(this) ;
}
if(nouvelleDonnees instanceof ListeObservation) {
getIMediateur().rafraichirMiniListeObservations((ListeObservation)nouvelleDonnees) ;
}
if(nouvelleDonnees instanceof Tree) {
rafraichirArbreMotsCles(nouvelleDonnees);
getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees);
}
}
 
/**
* Affiche les paires / valeur de tous les mots clés stockés
*/
public void afficherMotsCles() {
for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
String key = it.next();
String valeur = 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) {
String idImgs = "";
for (int i = 0; i < ids.length; i++) {
String idImageEnCours = "";
if (cacheImage.containsKey(ids[i])) {
ImageCarnet ic = cacheImage.get(ids[i]);
idImageEnCours = ic.getId();
ic.mettreAjourMotsCles(motsClesEnCours);
}
idImgs += idImageEnCours;
idImgs += (i < (ids.length - 1)) ? ",": "";
}
LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this);
liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours);
 
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("images");
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, Rafraichissable r) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
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();
if(!parentUsObj[1].equals("racine")) {
parentId = parentUsObj[1];
}
}
 
rafraichirArbreMotsCles(arbreMC);
mettreAjourMotsClesId(motCle, id);
 
String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
+ motCle + "&id=" + id + "&parent=" + parentId;
MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
}
 
/**
* 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, Rafraichissable r) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
String[] usObj = (String[]) n.getUserObject();
String id = usObj[1];
 
MCDao.supprimerBaseDeDonnees(id, r);
 
}
 
/**
* 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, Rafraichissable r) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
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();
if(!parentUsObj[1].equals("racine")) {
parentId = parentUsObj[1];
}
}
 
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.modifierBaseDeDonnees(motCleModifie, r);
 
}
 
/**
* 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, Rafraichissable r) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("images");
 
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();
if(!parentUsObj[1].equals("racine")) {
parentId = parentUsObj[1];
}
}
 
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.deplacerBaseDeDonnees(motCleModifie, r);
}
 
/**
* 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;
obtenirNombrePhotoGalerie(this);
}
 
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
* donnés en fonction de la taille de page en cours
*
* @param nbElements
* le nombre d'élements total
* @return le nombre de pages
*/
public int calculerNbPages(int nbElements) {
// A cause de la betise de java pour les conversion implicite on fait
// quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) arrondie à
// l'entier superieur
double nPage = (1.0 * nbElements) / (1.0 * taillePage);
double nPageRound = Math.ceil(nPage);
Double nPageInt = new Double(nPageRound);
 
// on convertit en entier
return nPageInt.intValue();
}
 
/**
* Recalcule la page en cours lors du changement du nombre d'élements
*
* @param nbElements
* le nombre d'élements total
* @return la nouvelle page encours
*/
public int calculerPageCourante(int nbElements) {
// on calcule le nombre de page
int nouvelNbPages = calculerNbPages(nbElements);
// la nouvelle page en cours
double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
* (1.0 * nouvelNbPages);
 
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante);
Double nPageInt = new Double(nPageRound);
 
// on convertit en entier
return Math.abs(nPageInt.intValue());
}
 
/**
* Change la taille de page et recalcule la page encours
*
* @param nouvelleTaillePage
* la nouvelle taille de page à utiliser
*/
public void changerTaillePage(int nouvelleTaillePage) {
taillePage = nouvelleTaillePage;
pageEncours = calculerPageCourante(nbElements);
obtenirNombrePhotoGalerie(this);
}
/**
* Met la valeur de la page en cours à la dernière
*/
public void setDernierePage() {
changerNumeroPage(pageMax);
}
 
/**
* Notifie le mediateur que l'upload ou le download est termine et qu'il
* faut rafraichir les vues avec les nouvelles données
*/
public void requeteTerminee() {
getIMediateur().demasquerChargement();
getIMediateur().rafraichirToutesVues();
}
 
/**
* Obtient l'identifiant de l'utilisateur auprès du médiateur
*
* @return id de l'utilisateur
*/
public String getIdentifiant() {
 
return getIMediateur().getIdentifiant();
}
 
/**
* renvoie la taille d'une image grâce à son identifiant
*
* @param id
* l'identifiant de l'image
* @return un tableau contenant la longueur et la hauteur de l'image
*/
public String[] obtenirTailleImage(String id) {
 
return (cacheImage.get(id)).getTailleImage();
 
}
 
/**
* Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
* renvoie la note associée au rafrachissable qui la demande
*
* @param r
* le rafraichissable demandeur de l'information
* @param id
* l'identifiant del'image
*/
public void obtenirNote(Rafraichissable r, String id) {
 
r.rafraichir((cacheImage.get(id)).getNote(), true);
 
}
 
/**
* Accesseur pour la configuration en cours d'utilisation
*
* @return la configuration
*/
public Configuration getConfig() {
 
return config;
}
 
/**
* Ajoute des images à la selection en cours
*
* @param ids
* les identifiants des images à ajouter
*/
public void ajouterImagesSelection(String[] ids) {
 
for (int i = 0; i < ids.length; i++) {
String idImg = cacheImage.get(ids[i]).getId();
selectionImages.add(idImg);
}
}
 
public int getCompteSelection() {
return selectionImages.size();
}
/**
* Vide la selection en cours
*/
public void viderSelection() {
selectionImages.clear();
}
 
public String renvoyerSelection() {
 
String selection = "";
if(selectionImages.size() <= 0)
{
selection += "-255" ;
}
else
{
for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
String idEncours = it.next();
selection += idEncours + ",";
}
}
 
return selection;
}
 
public void lierImagesObervations(String idsObs, String idsImg) {
LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
}
 
public void obtenirLiaisonObservations(ImageMediateur imageMediateur,
String id) {
String imgId = cacheImage.get(id).getId() ;
LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;
lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;
}
 
public void supprimerLiaisonImages(String[] idsImg, String idObs) {
String chaineIdImg = "";
for(int i = 0; i < idsImg.length; i++) {
String idImg = cacheImage.get(idsImg[i]).getId() ;
chaineIdImg += ","+idImg;
}
chaineIdImg = chaineIdImg.replaceFirst(",", "");
LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ;
}
 
public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) {
String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}} ;
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres);
}
 
public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) {
String[][] criteres = {{critere[0],critere[1]}} ;
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this);
noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres);
}
 
public void obtenirDatesImages(Rafraichissable r) {
ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this);
lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant());
}
public String obtenirIdPourOrdre(String ordreImage) {
return cacheImage.get(ordreImage).getId();
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
New file
0,0 → 1,425
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.tree.MultiSelectionModel;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreMotsClesFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
/**
* Les mots clés en cours
*/
private String motsClesEncours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private static TreePanel arbreMotsCles = null;
 
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
private boolean arbreInitialise = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
/**
* prefixe pour générer des ids adaptées
*/
private String prefixe = "_filtre" ;
private final String prefixeImg = "_images" ;
private final String prefixeObs = "_obs" ;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreMotsClesFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesFiltreVue(ImageMediateur im) {
 
// on crée le panel
super();
iMediateur = im;
this.prefixe += prefixeImg;
initialiserPanel();
}
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesFiltreVue(ObservationMediateur om) {
 
// on crée le panel
super();
oMediateur = om;
this.prefixe += prefixeObs;
initialiserPanel();
this.setLayout(new RowLayout());
 
}
public void initialiserPanel() {
// on crée le conteneur de l'arbre
arbreMotsCles = new TreePanel();
arbreMotsCles.setId("x-view-tree-filter"+prefixe);
 
MultiSelectionModel msModel = new MultiSelectionModel();
arbreMotsCles.setSelectionModel(msModel);
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine"+prefixe);
String[] usObject = { "Mots clés", "racine"+prefixe };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
 
@Override
public void onClick(Node node, EventObject e) {
if(!arbreInitialise) {
expand();
}
}
 
@Override
public void onExpand(Node node) {
if(!arbreInitialise) {
obtenirArbreMotsCles();
arbreInitialise = true;
}
}
 
});
this.setPaddings(5);
 
this.setBorder(false);
this.setCollapsible(true);
this.setAutoWidth(true);
 
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
@Override
public void onRender(Component component) {
 
// on interdit le drag and drop dans l'arbre
arbreMotsCles.setEnableDD(false);
arbreMotsCles.setAutoWidth(false);
arbreMotsCles.setAutoScroll(true);
arbreMotsCles.setBorder(false);
 
// on met en forme le layout
((Panel) component).add(arbreMotsCles,new RowLayoutData("80%"));
 
// on ajoute les listeners d'évenements
ajouterListeners();
//obtenirArbreMotsCles();
}
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des mots clés
*/
private void ajouterListeners() {
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
// gestion du clic sur un noeud
@Override
public void onClick(TreeNode node, EventObject e) {
 
e.stopEvent();
boolean multi = false;
if(e.hasModifier()) {
multi = true;
}
gererClicNoeud(node,multi);
}
});
}
/**
* Fonction de gestion sur le clic sur le noeud
*
* @param node
*/
public void gererClicNoeud(TreeNode node, boolean multi) {
if(!arbreInitialise) {
obtenirArbreMotsCles();
} else {
if(node.equals(arbreMotsCles.getRootNode())) {
arbreMotsCles.getSelectionModel().clearSelections();
} else {
((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi);
}
filtreModifie = true;
iMediateur.obtenirPhotoGalerie();
}
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on a reçu un arbre
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree) nouvelleDonnees;
// on vide tous les noeuds de l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
 
// et on recopie le nouvel arbre
MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
.getRootNode(), false);
 
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
if(!arbreInitialise) {
arbreInitialise = true;
}
arbreMotsCles.setRootNode(arbreMotsCles.getRootNode());
 
// l'état du filtre est réinitialisé
filtreModifie = false;
doLayout() ;
}
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
public ObservationMediateur getOMediateur() {
return oMediateur ;
}
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "mots clés";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
String val = "";
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
for(int i = 0; i< noeuds.length ; i++) {
if(noeuds[i].getDepth() > 0) {
String[] userObj = (String[])noeuds[i].getUserObject();
String idMotCle = noeuds[i].getId();
if(userObj != null && userObj[1] != null) {
idMotCle = userObj[1];
}
val += ";"+idMotCle;
}
}
val = val.replaceFirst(";", "");
String[] valeursFiltres = {"id_mots_cles", val};
 
return valeursFiltres;
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
public void mettreAJourMotsCles(String valeur, String id) {
if(getIMediateur() != null) {
getIMediateur().mettreAjourMotsClesId(valeur,
id);
}
else
{
getOMediateur().mettreAjourMotsClesId(valeur, id);
}
}
public void obtenirArbreMotsCles() {
if(getIMediateur() != null) {
getIMediateur().obtenirArbreMotsCles(this);
}
else
{
getOMediateur().obtenirArbreMotsCles(this);
}
}
 
@Override
public void valider() {
if (estInstancie) {
// on vide les mots clés en cours
motsClesEncours = "";
// on suppose que le filtre a change
filtreModifie = true;
}
}
 
public void raz() {
if(arbreInitialise) {
// on vide tous les noeuds de l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreInitialise = false ;
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine"+prefixe);
String[] usObject = { "Mots clés", "racine"+prefixe };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onClick(Node node, EventObject e) {
if(!arbreInitialise) {
expand();
}
}
@Override
public void onExpand(Node node) {
if(!arbreInitialise) {
obtenirArbreMotsCles();
arbreInitialise = true;
}
}
});
}
}
 
@Override
public void viderFiltre() {
motsClesEncours = "";
arbreMotsCles.getSelectionModel().clearSelections();
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/FenetreLicenceVue.java
New file
0,0 → 1,143
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.user.client.ui.CheckBox;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.FormPanel;
 
public class FenetreLicenceVue extends com.gwtext.client.widgets.Window implements Rafraichissable {
CarnetEnLigneMediateur cm = null;
private CheckBox accepterLicence = new CheckBox();
private Button validerAcceptationLicence = new Button("Valider");
private Button annulerAcceptationLicence = new Button("Refuser");
// C'est moche mais ça évite de la transmettre du serveur ou de créer un fichier de config pour la licence
// Todo afficher un texte provenant d'une url
private String licence = "Le \"carnet en ligne\" (CEL) est un service proposé par Tela Botanica dans le but de vous aider à garder la trace de vos observations de terrain afin qu'elles ne restent plus prisonnière de votre \"petit carnet à spirale\"... La saisie des données est rapide, sure et précise et le CEL vous permet de les archiver et de les trier facilement. Si vous les publiez, ce que nous vous invitons vivement à faire, mais sans obligation, elles seront visibles sur les cartes de répartition des espèces du site de Tela Botanica. De même, vous pourrez faire partager vos meilleures photos de plantes avec les autres membres du réseau. Vous pourrez également exporter vos observations saisies dans le CEL dans une table Excel pour les traiter statistiquement ou les transférez à d'autres botanistes ou dans d'autres logiciels.<br>"
+"<br>"
+"Pour cela vous devez accepter les conditions suivantes :<br>"
+"<br>"
+"1. <b>Etre inscrit au réseau Tela Botanica</b> : cette inscription est gratuite et vous trouverez toutes explications à l'adresse <a href=\"http://www.tela-botanica.org/page:rejoindre_reseau\">http://www.tela-botanica.org/page:rejoindre_reseau</a><br>"
+" "
+"<br>"
+"2. <b>En publiant vos observations sur le site de Tela Botanica vous acceptez de céder :</b><br>"
+"- <u>un droit d'usage interne à Tela Botanica</u>, non exclusif, non limité dans le temps et à titre gratuit, sur l’ensemble des données publiées, notamment celui de les détenir, de les dupliquer, de les archiver, de les agréger avec des données provenant d’autres sources et d’effectuer tout type de calcul permettant d’en extraire des informations de niveau général, comme des statistiques par exemple.<br>"
+"- <u>le droit à Tela Botanica de les diffuser librement et gratuitement</u>, sans limite de temps, à condition que le nom de l'auteur de l'observation soient cité ainsi que celui de Tela Botanica. Cependant, dans le cas ou une publication comprendrait plus de 100 auteurs différents, seule la mention \"réseau Tela Botanica\" pourra être mentionnée.<br>"
+"<br>"
+"3. <b>Vous pouvez à tout moment retirer de la publication les données que vous désirez</b>. Dans ce cas les clauses de l'article précédent ne s'appliqueront plus aux données ainsi retirées de la publication, sans toute fois pouvoir revenir sur les droits cédés antérieurement lors de leur publication initiale dans le cas ou ces données ait déjà été utilisées par des tiers. <br>"
+" "
+"<br>"
+"4. <b>En publiant vos photos</b> sur le site de TB lors de la publication de vos observations, vous acceptez de les mettre à disposition de la communauté sous une licence <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a>. Cette mise à disposition sous licence Creative Commons n'est applicable que pour le format réduit de vos clichés présenté sur le site Tela Botanica. Elle ne s'applique pas aux clichés dans leur format original en haute définition dont vous gardez la propriété exclusive.<br>"
+"Selon cette licence <a href=\"http://www.tela-botanica.org/page:licence\">Creative Commons</a> toute personne sera libre de reproduire, modifier, distribuer et communiquer les photos au public selon les conditions suivantes :<br>"
+"- citer le nom de l'auteur original de l'oeuvre ainsi que celui de Tela Botanica qui l'édite,<br>"
+"- s'il y a modification, transformation ou adaptation des oeuvres, vous cédez le droit de distribuer la création qui en résulte que sous un contrat identique à celui-ci,<br>"
+" "
+"- à chaque réutilisation ou distribution, doit apparaître clairement les conditions contractuelles de mise à disposition de cette création,<br>"
+"- chacune de ces conditions peut être levée s'il y a autorisation du titulaire des droits.<br>"
+"<br>"
+"5. <b>En publiant vos données (photos et/ou observations) sur le site de Tela Botanica</b> vous acceptez que les membres du réseau puissent vous contacter via votre adresse électronique pour discuter avec vous de la pertinence de votre détermination, de son lieu d'observation ou de l'intitulé de vos clichés.<br>"
+"<br>"
+"6. <b>Affichage de votre identité et de votre adresse électronique</b>. L'affichage de votre identité pourra apparaître selon les noms et prénoms que vous aurez renseigné lors de votre inscription au réseau Tela Botanica. Seule la partie précédent le signe @ de votre adresse électronique sera affichée afin d'éviter son utilisation par des tiers. Les messages qui vous parviendront seront envoyés par Tela Botanica via un dispositif garantissant le non piratage de votre adresse.<br>"
+"<br/><br/>"
;
public FenetreLicenceVue(CarnetEnLigneMediateur cm) {
super();
this.cm = cm;
setTitle("Acceptation de la licence du carnet en ligne");
Panel conteneurHtml = new Panel();
conteneurHtml.setHtml(licence);
conteneurHtml.setHeight(230);
conteneurHtml.setAutoScroll(true);
HTML conteneurLicence = new HTML();
conteneurHtml.add(conteneurLicence);
//licence = Configuration.getLicence();
setConstrain(true);
conteneurLicence.setHTML(licence);
this.add(conteneurHtml);
Panel conteneurCheckbox = new Panel();
conteneurCheckbox.setBorder(false);
conteneurCheckbox.setHeader(false);
Label labelCheckboxAccepterLicence = new Label();
labelCheckboxAccepterLicence.setStyleName("display:inline");
accepterLicence.setText(" J'ai lu et j'accepte la licence");
accepterLicence.setStyleName("accepter_licence");
FormPanel conteneurCheckboxEtValidation = new FormPanel();
conteneurCheckboxEtValidation.setHeader(false);
conteneurCheckboxEtValidation.setHeight(70);
conteneurCheckboxEtValidation.add(accepterLicence);
conteneurCheckboxEtValidation.add(labelCheckboxAccepterLicence);
conteneurCheckboxEtValidation.addButton(validerAcceptationLicence);
validerAcceptationLicence.setDisabled(true);
conteneurCheckboxEtValidation.addButton(annulerAcceptationLicence);
this.add(conteneurCheckboxEtValidation);
this.setClosable(false);
this.setHeight(320);
ajouterListenerBoutons();
}
public void ajouterListenerBoutons() {
accepterLicence.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
@Override
public void onValueChange(ValueChangeEvent<Boolean> event) {
validerAcceptationLicence.setDisabled(!event.getValue());
}
});
validerAcceptationLicence.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
 
cm.rafraichir("licence_acceptee", false);
}
});
annulerAcceptationLicence.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
 
cm.rafraichir("licence_refusee", false);
}
});
}
 
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
// TODO Auto-generated method stub
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java
New file
0,0 → 1,211
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.Event;
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.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextArea;
 
public class SaisieMotsClesVue extends Window implements Rafraichissable {
private ObservationMediateur oMediateur = null ;
private Object[][] listeMotsPesee = null;
private String motsAAjouter = "" ;
private int nbMotsClesMax = 1 ;
private TextArea motsClesAjout = null;
private Button validerAjout = null ;
private Button voirCacherNuage = null;
private boolean nuageVisible = false ;
private Panel contenuNuage = null ;
public SaisieMotsClesVue(ObservationMediateur om) {
super("Entrez vos mots clés");
setCls("fenmotcles");
oMediateur = om ;
//setWidth(300);
motsClesAjout = new TextArea();
//motsClesAjout.setWidth(300);
validerAjout = new Button("Valider");
voirCacherNuage= new Button("Afficher les mots clés");
final Rafraichissable r = this ;
this.setCloseAction(CLOSE);
validerAjout.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
motsAAjouter = motsClesAjout.getText();
//oMediateur.AjouterMotsClesEnMasse(motsAAjouter);
}
});
voirCacherNuage.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(nuageVisible) {
if(contenuNuage != null) {
contenuNuage.clear();
}
voirCacherNuage.setText("Afficher les mots clés");
nuageVisible = false;
}
else {
// oMediateur.obtenirNuageMotsCles(r);
voirCacherNuage.setText("Cacher les mots clés");
nuageVisible = true;
}
}
});
add(motsClesAjout);
add(validerAjout);
add(voirCacherNuage);
contenuNuage = new Panel();
contenuNuage.setBorder(false);
add(contenuNuage);
}
 
public boolean renvoyerEtatFiltre() {
// TODO Auto-generated method stub
return false;
}
 
 
public String renvoyerNomFiltre() {
// TODO Auto-generated method stub
return null;
}
 
 
public String[] renvoyerValeursAFiltrer() {
// TODO Auto-generated method stub
return null;
}
 
 
public void valider() {
// TODO Auto-generated method stub
}
 
 
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof Integer) {
nbMotsClesMax = (Integer)nouvelleDonnees;
demasquerChargement();
}
if(nouvelleDonnees instanceof Object[][]) {
listeMotsPesee = (Object[][])nouvelleDonnees ;
construireNuage();
demasquerChargement();
}
if(nouvelleDonnees instanceof String) {
String res = (String)nouvelleDonnees;
if(res.equals("OK")) {
masquerChargement();
oMediateur.obtenirListeObservation();
//oMediateur.obtenirNuageMotsCles(this);
}
}
}
private void construireNuage() {
contenuNuage.clear();
String contenu = "<ul class=\"nuagetag\">" ;
for(int i = 0; i<listeMotsPesee.length; i++) {
String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ;
contenu += "<li class=\""+classeMotCle+"\">";
contenu += (String)listeMotsPesee[i][0];
contenu += "</li>";
}
contenu += "</ul>" ;
HTML contenuHTML = new HTML(contenu) {
@Override
public void onBrowserEvent(Event e) {
motsAAjouter += " "+e.getTarget().getInnerHTML();
motsClesAjout.setValue(motsAAjouter);
}
};
contenuHTML.sinkEvents(Event.ONCLICK);
contenuNuage.add(contenuHTML);
contenuNuage.doLayout();
doLayout();
}
private int calculerPoids(int poidMot) {
int poids = (poidMot*10)/nbMotsClesMax;
if(poids < 1) {
return 1;
}
return poids;
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
 
if (masked!=null) {
masked.mask("Chargement") ;
}
 
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
masked.unmask() ;
}
}
 
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java
New file
0,0 → 1,116
package org.tela_botanica.client.vues.observation.filtres;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
 
public class RechercheLibreVue extends Panel implements Filtrable {
 
private ObservationMediateur oMediateur = null;
private TextField champRecherche = null;
private static String titrePanneau = "Recherche libre";
private String valeurRecherchee= "";
private Button boutonRechercher = null;
private boolean estModifie = true;
private final int KEY_ENTER = 13;
public RechercheLibreVue(ObservationMediateur om) {
super(titrePanneau);
oMediateur = om;
champRecherche = new TextField();
champRecherche.setWidth("90%");
boutonRechercher = new Button("Rechercher");
boutonRechercher.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
valider();
}
});
champRecherche.addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ENTER:
valider();
break;
}
}
});
add(champRecherche);
add(boutonRechercher);
setCollapsible(true);
setTitleCollapse(true);
setPaddings(5);
}
 
 
@Override
public boolean renvoyerEtatFiltre() {
return estModifie;
}
 
 
@Override
public String renvoyerNomFiltre() {
return "Recherche libre";
}
 
@Override
public String[] renvoyerValeursAFiltrer() {
String nom = "recherche";
if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) {
valeurRecherchee = champRecherche.getValueAsString();
} else {
valeurRecherchee = "";
}
String[] valeurs = {nom,valeurRecherchee};
return valeurs;
}
 
 
@Override
public void valider() {
if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) {
estModifie = true;
oMediateur.obtenirNombreObservation();
} else {
estModifie = false;
}
}
public void raz() {
if(champRecherche.isCreated()) {
champRecherche.reset();
valeurRecherchee = "";
}
}
 
@Override
public void viderFiltre() {
champRecherche.setValue("");
valeurRecherchee = "";
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java
New file
0,0 → 1,642
package org.tela_botanica.client.vues.observation.filtres;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
 
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
import com.gwtext.client.core.EventObject;
 
/**
* Arbre Filtrant sur les entites geographiques
*
*
* @author aurelien + david
*
*/
 
 
public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
/**
* Les localites en cours
*/
private String entitesGeographiquesEncours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreEntitesGeographiques = null;
 
 
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
private boolean arbreCharge = false ;
 
private String nomFiltre = "" ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreEntiteGeographiqueObservationFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {
 
// on crée le panel
super("Localités");
this.observationMediateur = obs;
 
arbreEntitesGeographiques = new TreePanel();
 
this.setPaddings(5);
 
this.setCollapsible(true);
this.setAutoScroll(true);
 
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
@Override
public void onRender(Component component) {
 
// on interdit le drag and drop dans l'arbre
arbreEntitesGeographiques.setEnableDD(false);
arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Localités");
root.setId("racine_entite");
String[] usObject = { "Localités" };
root.setUserObject(usObject);
 
arbreEntitesGeographiques.setRootNode(root);
arbreEntitesGeographiques.setRootVisible(true);
arbreEntitesGeographiques.setBorder(false);
root.setExpandable(true) ;
 
add(arbreEntitesGeographiques);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
// enfin on considère le composant comme instancié
estInstancie = true;
 
}
 
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des entites
*/
private void ajouterListeners() {
arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() {
@Override
public void onClick(TreeNode node, EventObject e) {
gererClicNoeud(node);
}
}) ;
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirListeEntiteGeographique() ;
arbreCharge = true ;
}
}
}) ;
}
private void gererClicNoeud(TreeNode node) {
mettreAJourValeurEnCours(node);
observationMediateur.obtenirNombreObservation() ;
}
private void mettreAJourValeurEnCours(TreeNode node) {
nomFiltre = "" ;
entitesGeographiquesEncours = "" ;
String nomPere = "" ;
String nomGrandPere = "" ;
String nomArriereGrandPere = "";
switch(node.getDepth())
{
case 0:
if(!arbreCharge)
{
arbreEntitesGeographiques.getRootNode().expand();
}
else
{
observationMediateur.obtenirNombreObservation() ;
}
return ;
case 4: nomFiltre += "station,lieudit,commune,departement";
nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ;
entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ;
break;
case 3: nomFiltre += "lieudit,commune,departement";
nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ;
break;
case 2: nomFiltre += "commune,departement";
nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
entitesGeographiquesEncours += node.getText()+","+nomPere ;
break;
case 1: nomFiltre += "departement";
entitesGeographiquesEncours += node.getText() ;
break;
default:
break;
}
filtreModifie = true ;
}
public void initialiser() {
arbreCharge = false ;
entitesGeographiquesEncours = "";
arbreEntitesGeographiques.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirListeEntiteGeographique() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
// on crée un arbre vide
Tree nouvelArbre = new Tree() ;
TreeNode root = new TreeNode();
root.setId("racine_entite");
root.setText("Localités");
String[] usObjRoot = { "Localités"};
root.setUserObject(usObjRoot);
nouvelArbre.setRootNode(root);
// on vide tous les noeuds
arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {
@Override
public boolean execute(Node node) {
node.remove();
return true;
}
});
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
EntiteGeographiqueObservation ent=data.get(it.next());
creerHierarchieNoeud(nouvelArbre ,root, ent);
doLayout();
}
copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode());
arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ;
 
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
// l'état du filtre est réinitialisé
filtreModifie = false;
//show() ;
arbreEntitesGeographiques.doLayout();
 
}
if(nouvelleDonnees instanceof Observation)
{
// Cas d'ajout unitaire d'une observation
// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
// de l'arbre
if(!arbreCharge) {
return;
}
Observation obs = (Observation)nouvelleDonnees ;
EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation());
creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent);
doLayout();
arbreEntitesGeographiques.doLayout() ;
}
}
 
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreEntitesGeographiques;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "Localités";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
 
valider();
String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ;
 
return valeursFiltrees;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setUserObject(usObj);
child.setId(""+usObj[1]);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
@Override
public void valider() {
if (estInstancie) {
}
}
public Comparator<TreeNode> comparerNoeuds()
{
return new Comparator<TreeNode>() {
 
@Override
public int compare(TreeNode o1, TreeNode o2) {
if(o1.getText().equals("Inconnue")) {
return -1 ;
}
if(o2.getText().equals("Inconnue")) {
return 1 ;
}
if(o1.getDepth() == 1 && o2.getDepth() == 1)
{
String l1 = o1.getText() ;
String l2 = o2.getText() ;
if(l1.length() == 1) {
l1 = "0"+l1;
}
if(l2.length() == 1) {
l2 = "0"+l2;
}
Integer n1 = 0;
Integer n2 = 0;
try{
n1 = Integer.parseInt(l1) ;
n2 = Integer.parseInt(l2) ;
} catch(NumberFormatException ne) {
n1 = 0;
n2 = 0;
}
return n1.compareTo(n2) ;
}
else
{
String n1 = o1.getId() ;
String n2 = o2.getId() ;
return n1.compareToIgnoreCase(n2);
}
}
} ;
}
 
public void raz() {
arbreCharge = false ;
arbreEntitesGeographiques.collapseAll();
arbreEntitesGeographiques.clear() ;
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Localités");
root.setId("racine_entite");
String[] usObject = { "Localités" };
root.setUserObject(usObject);
 
arbreEntitesGeographiques.setRootNode(root);
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
entitesGeographiquesEncours = "";
}
private TreeNode creerNoeud(String id, String texte) {
TreeNode nouveauNoeud = new TreeNode();
nouveauNoeud.setId(""+(id));
nouveauNoeud.setText(texte);
String[] usObj = {texte,id+""};
nouveauNoeud.setUserObject(usObj);
return nouveauNoeud;
}
/**
*
* @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds
* @param root le noeud racine auquel on concatène la hierarchie crée
* @param ent l'entité géographique qui doit être décomposée en arborescence
* @return
*/
private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) {
String id_zone_geo=null;
String zone_geo=null;
String lieuDit=null;
String station=null;
// TODO creer une fonction plus efficace lors du passage au multi reférentiel
id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo());
id_zone_geo = id_zone_geo.replaceAll("\"", "");
id_zone_geo = id_zone_geo.replace('\\',' ');
id_zone_geo = id_zone_geo.trim();
zone_geo = ent.getZoneGeo();
lieuDit = ent.getLieuDit();
station = ent.getStation();
if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) {
id_zone_geo="Inconnue" ;
}
if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) {
zone_geo="Inconnue" ;
}
if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
lieuDit="Inconnue" ;
}
if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) {
station="Inconnue" ;
}
Node noeudMemeId = arbre.getNodeById(""+id_zone_geo);
if(noeudMemeId == null) {
// on crée le noeud de l'identifiant zone_geo
noeudMemeId = creerNoeud(""+id_zone_geo,id_zone_geo);
root.appendChild(noeudMemeId) ;
}
// on teste si la localité existe
Node noeudMemeLoc = arbre.getNodeById(""+(id_zone_geo+zone_geo));
if(noeudMemeLoc == null)
{
// on crée le noeud de la zone_geo
noeudMemeLoc = creerNoeud(""+id_zone_geo+zone_geo, zone_geo);
noeudMemeId.appendChild(noeudMemeLoc) ;
}
// on teste si le lieu dit existe
Node noeudMemeLieu = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit));
if(noeudMemeLieu == null)
{
// on crée le noeud du lieu dit
noeudMemeLieu = creerNoeud(id_zone_geo+zone_geo+lieuDit, lieuDit);
noeudMemeLoc.appendChild(noeudMemeLieu) ;
}
// on teste si la station existe
Node noeudMemeStation = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit+station));
if(noeudMemeStation == null) {
// on crée le noeud de la station
noeudMemeStation = creerNoeud(id_zone_geo+zone_geo+lieuDit+station,station);
noeudMemeLieu.appendChild(noeudMemeStation);
}
root.sort(comparerNoeuds()) ;
}
 
@Override
public void viderFiltre() {
arbreEntitesGeographiques.getSelectionModel().clearSelections();
entitesGeographiquesEncours ="";
}
 
public void viderFiltre(String nom) {
final int profondeur = calculerProfondeurPourNomFiltre(nom);
// on vide tous les noeuds
arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() {
 
@Override
public boolean execute(Node node) {
boolean continuer = true;
TreeNode noeudArbreEncours = (TreeNode)node;
if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) {
int profondeurDepart = noeudArbreEncours.getDepth();
for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {
noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();
}
arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours);
mettreAJourValeurEnCours(noeudArbreEncours);
continuer = false;
}
return continuer;
}
 
});
}
private int calculerProfondeurPourNomFiltre(String nom) {
int profondeur = 0;
if(nom.equals("departement")) {
profondeur = 1;
}
if(nom.equals("commune")) {
profondeur = 2;
}
if(nom.equals("lieudit")) {
profondeur = 3;
}
if(nom.equals("station")) {
profondeur = 4;
}
return profondeur;
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java
New file
0,0 → 1,681
package org.tela_botanica.client.vues.observation.filtres;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.DateObservation;
import org.tela_botanica.client.modeles.objets.ListeDate;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
 
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
import com.gwtext.client.core.EventObject;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
/**
* Les localites en cours
*/
private String donneesDateEnCours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreDonneesDates = null;
 
/**
* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
*/
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
private boolean arbreCharge = false ;
 
private String nomFiltre = "" ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreDateObservationFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreDateObservationFiltreVue(ObservationMediateur obs) {
 
// on crée le panel
super("Dates");
this.observationMediateur = obs;
 
arbreDonneesDates = new TreePanel();
 
this.setPaddings(5);
 
this.setCollapsible(true);
this.setAutoScroll(true);
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
@Override
public void onRender(Component component) {
 
// on interdit le drag and drop dans l'arbre
arbreDonneesDates.setEnableDD(false);
arbreDonneesDates.setId("x-view-tree-filter-date");
arbreDonneesDates.setBorder(false);
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Dates");
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", "racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.setRootVisible(true);
arbreDonneesDates.setBorder(false);
root.setExpandable(true) ;
 
add(arbreDonneesDates);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
// enfin on considère le composant comme instancié
estInstancie = true;
 
}
 
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des entites
*/
private void ajouterListeners() {
arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
@Override
public void onClick(TreeNode node, EventObject e) {
gererClicNoeud(node);
}
}) ;
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
}
private void gererClicNoeud(TreeNode node) {
mettreAJourValeurEnCours(node);
observationMediateur.obtenirNombreObservation() ;
}
private void mettreAJourValeurEnCours(TreeNode node) {
nomFiltre = "" ;
donneesDateEnCours = "" ;
String nomPere = "" ;
String nomGrandPere = "" ;
switch(node.getDepth())
{
case 0:
if(arbreCharge) {
nomFiltre = "";
donneesDateEnCours = "";
}
break;
case 3: nomFiltre += "annee,mois,jour";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 2: nomFiltre += "annee,mois";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 1: nomFiltre += "annee";
donneesDateEnCours += ((String[])node.getUserObject())[1] ;
break;
default:
break;
}
filtreModifie = true ;
}
public void initialiser() {
arbreCharge = false ;
donneesDateEnCours = "";
arbreDonneesDates.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if (nouvelleDonnees instanceof ListeDate) {
String annee=null;
String mois=null;
String jour=null;
ListeDate data = (ListeDate) nouvelleDonnees ;
// on crée un arbre vide
TreeNode root = new TreeNode();
root.setId("racine_date");
root.setText("Dates");
String[] usObjRoot = { "Dates", "Dates", "racine_date"};
root.setUserObject(usObjRoot);
Tree nouvelArbre = new Tree();
nouvelArbre.setRootNode(root);
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
DateObservation ent=data.get(it.next());
annee= ent.getAnnee() ;
mois= ent.getMois() ;
String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;
jour= ent.getJour() ;
if(annee.contains("0000")) {
annee="Inconnue" ;
}
if(jour.contains("00")) {
jour="Inconnue" ;
}
Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee);
// si la région existe déjà
if(noeudMemeAnnee != null)
{
// on teste si la localité existe
Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois));
if(noeudMemeMois != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour));
if(noeudMemeJour != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
noeudMemeMois.appendChild(node_jour) ;
String[] usObj = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj);
}
}
else
{
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
noeudMemeAnnee.appendChild(node_mois) ;
String[] usObj = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj);
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj2 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj2);
}
}
else
{
TreeNode node_annee = new TreeNode();
node_annee.setId(""+annee);
node_annee.setText(annee);
root.appendChild(node_annee) ;
String[] usObj = {annee, annee, annee};
node_annee.setUserObject(usObj);
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
node_annee.appendChild(node_mois) ;
String[] usObj2 = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj2);
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj3 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj3);
}
 
}
// on trie
root.sort(comparerNoeuds()) ;
// on vide tous les noeuds
arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
@Override
public boolean execute(Node node) {
node.remove();
return true;
}
});
 
// et on recopie le nouvel arbre
copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates
.getRootNode());
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
// l'état du filtre est réinitialisé
filtreModifie = false;
//show() ;
doLayout();
 
}
if(nouvelleDonnees instanceof Observation)
{
// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
// de l'arbre
if(!arbreCharge) {
return;
}
Observation ent = (Observation)nouvelleDonnees ;
String dateSpl[] = ent.getDate().split("/") ;
String annee= dateSpl[2];
String mois= dateSpl[1];
String jour= dateSpl[0];
String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;
Node root = arbreDonneesDates.getRootNode() ;
if(annee.contains("0000") || annee.equals(null)) {
annee="Inconnue" ;
}
if(jour.contains("00") || jour.equals(null)) {
jour="Inconnue" ;
}
Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee);
// si la région existe déjà
if(noeudMemeAnnee != null)
{
// on teste si la localité existe
Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois));
if(noeudMemeMois != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour));
if(noeudMemeJour != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj);
noeudMemeMois.appendChild(node_jour) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
String[] usObj = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj);
noeudMemeAnnee.appendChild(node_mois) ;
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj2 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj2);
node_mois.appendChild(node_jour) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
TreeNode node_annee = new TreeNode();
node_annee.setId(""+annee);
node_annee.setText(annee);
String[] usObj = {annee,annee,annee};
node_annee.setUserObject(usObj);
root.appendChild(node_annee) ;
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
String[] usObj2 = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj2);
node_annee.appendChild(node_mois) ;
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj3 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj3);
node_mois.appendChild(node_jour) ;
// TODO : améliorer la compararaison des noeuds
root.sort(comparerNoeuds()) ;
}
arbreDonneesDates.doLayout() ;
}
}
 
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreDonneesDates;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "Dates";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
 
valider();
String valeursFiltrees[] = {nomFiltre, donneesDateEnCours } ;
 
return valeursFiltrees;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setUserObject(usObj);
child.setId(""+usObj[2]);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
@Override
public void valider() {
if (estInstancie) {
}
}
public Comparator<TreeNode> comparerNoeuds()
{
return new Comparator<TreeNode>() {
 
@Override
public int compare(TreeNode o1, TreeNode o2) {
String n1 = ((String[])o1.getUserObject())[1] ;
String n2 = ((String[])o2.getUserObject())[1] ;
return n1.compareTo(n2) ;
}
} ;
}
 
public void raz() {
arbreCharge = false ;
arbreDonneesDates.collapseAll();
arbreDonneesDates.clear();
TreeNode root = new TreeNode("Dates");
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", "racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
this.doLayout() ;
donneesDateEnCours = "";
}
 
@Override
public void viderFiltre() {
arbreDonneesDates.getSelectionModel().clearSelections();
donneesDateEnCours = "";
}
 
public void viderFiltre(String nom) {
final int profondeur = calculerProfondeurPourNomFiltre(nom);
// on vide tous les noeuds
arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() {
 
@Override
public boolean execute(Node node) {
boolean continuer = true;
TreeNode noeudArbreEncours = (TreeNode)node;
if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) {
int profondeurDepart = noeudArbreEncours.getDepth();
for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {
noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();
}
arbreDonneesDates.getSelectionModel().select(noeudArbreEncours);
mettreAJourValeurEnCours(noeudArbreEncours);
continuer = false;
}
return continuer;
}
 
});
}
private int calculerProfondeurPourNomFiltre(String nom) {
int profondeur = 0;
if(nom.equals("annee")) {
profondeur = 1;
}
if(nom.equals("mois")) {
profondeur = 2;
}
if(nom.equals("jour")) {
profondeur = 3;
}
return profondeur;
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java
New file
0,0 → 1,783
package org.tela_botanica.client.vues.observation.filtres;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDrop;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
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.DropNodeCallback;
import com.gwtext.client.widgets.tree.MultiSelectionModel;
import com.gwtext.client.widgets.tree.TreeDragData;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable, Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
 
/**
* Le treepanel qui affiche l'arbre
*/
private static TreePanel arbreMotsCles = null;
/**
* L'éditeur qui permet de modifier les mots clés dans l'arbre
*/
private TreeEditor te = null;
/**
* Le textfield associé à l'éditeur
*/
private TextField tfEdit = null;
/**
* Bouton de validation
*/
private Button ajouterMotCle = null;
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par
* des virgules
*/
private String motsClesEnCours = "";
/**
* Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
* (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
* du conteneur n'ai été effectué)
*/
private String[] motsClesEnAttente = new String[0];
/**
* Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
* noeud
*/
private boolean ajoutNoeud = false;
/**
* Booléen d'évènement qui sert à savoir si on est en train de modifier un
* noeud
*/
private boolean modifNoeud = false;
/**
* Booléen d'instanciation du conteneur
*/
private boolean arbreCharge = false;
/**
* Booléen nécessaire pour l'affichage
*
*/
private boolean estInstancie = false;
/**
* Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
*/
private boolean motsCleInitialises;
private Component livue = null;
MultiSelectionModel msModel = null;
 
private String cheminTemporaireAjout = null;
public Rafraichissable thisRafraichissable;
 
/**
* Constructeur sans paramètre (privé car interdit d'utilisation)
*/
@SuppressWarnings("unused")
private ArbreMotsClesObservationVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesObservationVue(ObservationMediateur om) {
// on crée le panel
super("Projets");
this.setLayout(new VerticalLayout());
oMediateur = om;
setBorder(false);
setCollapsible(true);
setTitleCollapse(true);
setAutoScroll(true);
 
// on ajoute les listeners
ajouterListenersPanel();
 
}
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
@Override
public void onRender(Component component) {
livue = oMediateur.getListeObservation();
// on crée le conteneur de l'arbre
arbreMotsCles = new TreePanel();
// on permet le drag and drop dans l'arbre
//arbreMotsCles.setEnableDD(true);
arbreMotsCles.setId("x-view-tree-keyword-obs");
msModel = new MultiSelectionModel();
arbreMotsCles.setSelectionModel(msModel);
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Projets");
root.setId("racine_obs");
String[] usObject = { "Projets", "racine_obs" };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
// on crée l'éditeur pour l'arbre
tfEdit = new TextField();
te = new TreeEditor(arbreMotsCles, tfEdit);
ajouterMotCle = new Button("Ajouter un projet");
arbreMotsCles.add(te);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onClick(Node node, EventObject e) {
if(!arbreCharge) {
expand();
}
}
 
@Override
public void onExpand(Node node) {
if(!arbreCharge) {
obtenirArbreMotsCles();
arbreCharge = true;
}
}
});
 
// on interdit le drag and drop dans l'arbre
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
// on met en forme le layout
add(arbreMotsCles);
add(ajouterMotCle);
 
// enfin on considère le composant comme instancié
estInstancie = true;
configDragAndDrop();
// on ajoute les listeners d'évenements
ajouterListeners();
}
 
});
}
 
/**
* Acesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
private ObservationMediateur getOMediateur() {
 
return oMediateur;
 
}
 
/**
* Acesseur pour l'arbre des mots clés
*
* @return le panel contenant l'arbre
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Accesseur pour l'éditeur
*
* @return l'éditeur associé à l'arbre
*/
public TreeEditor getTe() {
return te;
}
 
/**
* Acesseur pour le TextField associé à l'éditeur
*
* @return le champ texte associé à l'éditeur
*/
public TextField getTfEdit() {
return tfEdit;
}
 
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners() {
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
 
// gestion du clic sur un noeud
@Override
public void onClick(TreeNode node, EventObject e) {
 
e.stopEvent();
boolean multi = false;
if(e.hasModifier()) {
multi = true;
}
gererClicNoeud(node,multi);
}
 
// gestion du clic droit sur un noeud
@Override
public void onContextMenu(TreeNode node, EventObject e) {
 
e.stopEvent();
montrerContextMenuArbre(node, e, getTe());
 
}
 
// gestion du double clic sur un noeud
@Override
public void onDblClick(TreeNode node, EventObject e) {
 
modifNoeud = true;
if (!node.getId().equals("racine_obs")) {
te.startEdit(node);
}
}
 
// gestion de la modification du texte d'un noeud
@Override
public void onTextChange(TreeNode node, String text, String oldText) {
if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
te.startEdit(node);
Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
return;
}
if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
te.startEdit(node);
Window.alert("Un mot clé de même nom existe déjà à cette position");
return;
}
 
// on récupère les informations associées au noeud
TreeNode nd = node;
String[] usObject = new String[2];
usObject[0] = text;
usObject[1] = ((String[]) nd.getUserObject())[1];
nd.setUserObject(usObject);
 
// si c'est un nouveau noeud
if (ajoutNoeud) {
ajouterMotCleDansArbreMediateur(nd);
}
// si c'est noeud déjà existant
else {
if (modifNoeud) {
modifierMotCleDansArbreMediateur(nd);
}
}
//arbreMotsCles.disable();
}
@Override
public boolean doBeforeMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
boolean ok = true;
if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
ok = false;
Window.alert("Un mot clé de même nom existe déjà à cette position");
}
return ok;
}
@Override
public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
DragData dragData, String point, DragDrop source,
TreeNode dropNode) {
boolean ok = true;
if(dragData instanceof TreeDragData) {
ok = MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
}
return ok;
}
 
// gestion du déplacement d'un noeud
@Override
public void onMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
// on notifie le médiateur et on lui passe l'arbre
getOMediateur().deplacerMotCleDansArbre(node,
getArbreMotsCles().getTree());
}
@Override
public boolean doBeforeNodeDrop(TreePanel treePanel,
TreeNode target, DragData dragData,
String point, DragDrop source,
TreeNode dropNode,
DropNodeCallback dropNodeCallback) {
if(dragData instanceof TreeDragData) {
return true;
}
String idMotCle = ((String[])target.getUserObject())[1];
if(oMediateur.gererDDObsSurMotCle(target, dragData)) {
cocherMotCle(idMotCle);
return true;
}
return false;
}
 
 
@Override
public void onNodeDrop(TreePanel treePanel,
TreeNode target, DragData dragData,
String point, DragDrop source, TreeNode dropNode) {
 
}
 
});
 
// gestion de la validation
ajouterMotCle.addListener(new ButtonListenerAdapter() {
 
// lors du clic
@Override
public void onClick(Button button, EventObject e) {
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
TreeNode noeudAjout;
if(noeuds.length > 0) {
noeudAjout = noeuds[noeuds.length - 1];
} else {
noeudAjout = arbreMotsCles.getRootNode();
}
 
ajouterNoeud(noeudAjout);
}
});
 
}
private void ajouterMotCleDansArbreMediateur(TreeNode nd) {
// on notifie le médiateur de l'ajout et on lui passe
// l'arbre
getOMediateur().ajouterMotCleDansArbre(nd,
getArbreMotsCles().getTree(), this);
// et considère l'ajout achevé
ajoutNoeud = false;
}
private void modifierMotCleDansArbreMediateur(TreeNode nd) {
// on notifie le médiateur de la modification et on lui
// passe l'arbre
getOMediateur().modifierMotCleDansArbre(nd,
getArbreMotsCles().getTree());
// et on considère la modification achevée
modifNoeud = false;
}
/**
* Configure le drag 'n drop pour la liste
*/
private void configDragAndDrop()
{
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
arbreMotsCles.setDdGroup("ObsMotsClesGroup");
//arbreMotsCles.setEnableDD(true);
arbreMotsCles.setEnableDrag(true);
arbreMotsCles.setEnableDrop(true);
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("ObsMotsClesGroup");
}
 
/**
* Envoie une demande au médiateur pour obtenir l'arbre des mots clés
*/
public void obtenirArbreMotsCles() {
 
getOMediateur().obtenirArbreMotsCles(this);
 
}
 
/**
* Supprime un noeud de l'arbre
*
* @param n
* le noeud à supprimer
*/
public void supprimerNoeud(TreeNode n) {
// si ça n'est pas la racine (qu'on ne peut pas supprimer)
if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) {
// on détache le noeud et on le détruit
n.getParentNode().removeChild(n);
n.destroy();
// puis on en notifie le médiateur en lui passant le noeud supprimé
// et l'arbre
getOMediateur()
.supprimerMotCleDansArbre(n, arbreMotsCles.getTree(), this);
}
} else {
// si l'utilisateur tente de supprimer la racine, on l'avertit de
// son erreur
Window.alert("Impossible de supprimer la racine de l'arbre");
}
}
 
/**
* Ajoute un noeud dans l'arbre au parent donné
*
* @param parent
* le futur parent du noeud à ajouter
*/
public void ajouterNoeud(TreeNode parent) {
if(parent == null) {
parent = arbreMotsCles.getRootNode();
}
ajoutNoeud = true;
TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
cheminTemporaireAjout = nd.getId();
te.startEdit(nd);
}
/**
* Fonction de gestion sur le clic sur le noeud
*
* @param node
*/
public void gererClicNoeud(TreeNode node, boolean multi) {
if(!arbreCharge) {
obtenirArbreMotsCles();
} else {
if(multi) {
}
((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi);
oMediateur.obtenirNombreObservation();
}
}
 
/**
* Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
* clés à cocher
*
* @param motsClesIds
* un tableau contenant les identifiants des mots clés à cocher
*/
public void cocherMotsCles(final String[] motsClesIds) {
if (getArbreMotsCles() != null
&& getArbreMotsCles().getRootNode() != null) {
// à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// pour chaque noeud
@Override
public boolean execute(Node node) {
// on parcourt le tableau des mots clés
for (int i = 0; i < motsClesIds.length; i++) {
// si le mot clé fait partie des id à cocher on
// le coche
String usObject[] = (String[]) node
.getUserObject();
String nodeId = usObject[1];
if (nodeId.equals(motsClesIds[i])) {
getArbreMotsCles().getNodeById(nodeId)
.getUI().getTextEl().addClassName("x-tree-node-text-kw");
return true;
}
}
if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) {
getArbreMotsCles().getNodeById(node.getId())
.getUI().getTextEl().removeClassName("x-tree-node-text-kw");
}
 
// et on passe au suivant
return true;
}
 
});
}
else {
motsClesEnAttente = motsClesIds ;
}
}
public void cocherMotCle(String motCleId) {
if(getArbreMotsCles().getNodeById(motCleId) != null) {
getArbreMotsCles().getNodeById(motCleId)
.getUI().getTextEl().addClassName("x-tree-node-text-kw");
}
 
}
public void initialiser() {
arbreCharge = false ;
motsClesEnCours = "";
arbreMotsCles.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
obtenirArbreMotsCles() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données pour l'objet
* @param repandreRafraichissement
* booleen qui dit si on doit répandre l'évenement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
arbreMotsCles.enable();
if(nouvelleDonnees instanceof Tree) {
 
Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
// on prend sa racine et on l'attache à l'arbre des mots clés
Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), false);
 
// si l'arbre n'était pas encore considéré comme instancié
if (!arbreCharge) {
// on signale que oui
arbreCharge = true;
}
 
// s'il y a des mots clés en attente (lors du premier rendering)
if (motsCleInitialises == false && motsClesEnAttente != null) {
// on les coche
cocherMotsCles(motsClesEnAttente) ;
motsCleInitialises = true;
}
if(motsClesEnAttente.length > 0) {
cocherMotsCles(motsClesEnAttente);
}
}
 
// Si on reçoit un tableau de String (cas ou l'on séléectionne une
// nouvelle obs)
if (nouvelleDonnees instanceof String) {
String chaineMc = (String)nouvelleDonnees;
String[] motsClesIds = chaineMc.split(";");
// et que l'arbre est instancié
if (arbreCharge) {
// le tableau de String contient les id des mots clés associés à
// l'image
// on coche les mots clés contenu dans le tableau
cocherMotsCles(motsClesIds);
}
// si l'arbre n'est pas encore instancié on met les mots clés en
// attente
else {
motsClesEnAttente = motsClesIds;
}
}
// reception d'un nouvel identifiant de mot clé
if(nouvelleDonnees instanceof Integer) {
if(cheminTemporaireAjout != null) {
String id = ((Integer)(nouvelleDonnees)).toString();
TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
String[] userObj = {noeudEnAjout.getText(), id};
noeudEnAjout.setUserObject(userObj);
cheminTemporaireAjout = null;
}
}
}
public void raz() {
arbreCharge = false ;
arbreMotsCles.collapseAll();
arbreMotsCles.clear() ;
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Projets");
root.setId("racine_obs");
String[] usObject = { "Projets", "racine_obs" };
root.setUserObject(usObject);
root.setExpandable(true);
 
arbreMotsCles.setRootNode(root);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
obtenirArbreMotsCles() ;
arbreCharge = true ;
}
}
}) ;
motsClesEnCours = "";
}
 
@Override
public boolean renvoyerEtatFiltre() {
// TODO Auto-generated method stub
return false;
}
 
@Override
public String renvoyerNomFiltre() {
// TODO Auto-generated method stub
return null;
}
 
@Override
public String[] renvoyerValeursAFiltrer() {
String val = "";
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
for(int i = 0; i< noeuds.length ; i++) {
if(noeuds[i].getDepth() > 0) {
String usObject[] = (String[]) noeuds[i]
.getUserObject();
String nodeId = usObject[1];
val += ";"+nodeId;
}
}
val = val.replaceFirst(";", "");
String[] valeursFiltres = {"id_mots_cles", val};
return valeursFiltres;
}
 
@Override
public void valider() {
// TODO Auto-generated method stub
}
 
public void montrerContextMenuArbre(final TreeNode n, EventObject e,
TreeEditor te) {
Menu mn = new Menu();
final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
"Ajouter un projet");
final com.gwtext.client.widgets.menu.Item suppN = new Item(
"Supprimer projet");
 
mn.addItem(ajoutN);
mn.addItem(suppN);
 
mn.addListener(new MenuListenerAdapter() {
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
if (item.equals(suppN)) {
supprimerNoeud(n);
}
if (item.equals(ajoutN)) {
ajouterNoeud(n);
}
}
});
 
mn.showAt(e.getXY());
}
 
@Override
public void viderFiltre() {
arbreMotsCles.getSelectionModel().clearSelections();
motsClesEnCours = "";
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java
New file
0,0 → 1,87
package org.tela_botanica.client.vues.observation.indicateurs;
 
import org.tela_botanica.client.cel2;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.widgets.Panel;
 
public class LienExterneVue extends Panel implements Rafraichissable {
private ObservationMediateur oMediateur = null;
private String refTax = "";
 
private String numTax = "";
private String efloreBaseUrl = "";
private Label titreLien = new Label("Voir la fiche eflore");
public LienExterneVue(ObservationMediateur om) {
 
refTax = verifierEtFormaterReferentiel(om.getRefTaxSelectionne().getCode());
efloreBaseUrl = Configuration.getLienEfloreBaseUrl();
titreLien.setVisible(false);
setBorder(false);
titreLien.addClickHandler(new ClickHandler() {
 
@Override
public void onClick(ClickEvent event) {
if(!numTax.trim().equals("")) {
Window.open("http://"+efloreBaseUrl+"/"+refTax+"-nn-"+numTax,"","");
}
}
});
titreLien.setStyleName("lien_actif");
add(titreLien);
}
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
 
String[] nouvellesDonnees = (String[]) nouvelleDonnees;
String nouveauNumTax = nouvellesDonnees[0];
String codeRef = nouvellesDonnees[1];
 
if(nouveauNumTax.trim().equals("") || codeRef.trim().equals("autre") || nouveauNumTax.trim().equals("0") || codeRef.trim().equals("")) {
titreLien.setVisible(false);
} else {
if(!titreLien.isVisible()) {
titreLien.setVisible(true);
}
numTax = nouveauNumTax;
refTax = verifierEtFormaterReferentiel(codeRef);
}
}
 
public String verifierEtFormaterReferentiel(String refTax) {
// Sert simplement à exclure les vieux formats de référentiel
// du genre bdtfx:v2.00 ou bien bdnff.v1_01 etc...
// TODO: nettoyer également la base de données
String retour = refTax;
if(retour != null && !retour.isEmpty()) {
if (retour.contains(":")) {
retour = retour.split(":")[0];
}
if(retour.contains(".")) {
retour = retour.split(".")[0];
}
}
return retour;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java
New file
0,0 → 1,597
package org.tela_botanica.client.vues.observation.indicateurs;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.LoadEvent;
import com.google.gwt.event.dom.client.LoadHandler;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.core.AnimationConfig;
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.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
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;
 
/**
* Panneau d'affichage d'une image avec des boutons précdents et suivant
*
* @author aurelien
*
*/
public class MiniZoomImageVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
/**
* Le titre du panneau
*/
private static String titrePanneau = "Images liées";
 
/**
* Panneau conteneur pour l'image
*/
private Panel imageConteneur = null;
/**
* l'image à afficher
*/
private Image image = new Image("");
/**
* Bouton précédent
*/
private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
/**
* Bouton suivant
*/
private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
 
/**
* Taille originale Y de l'image
*/
private int imageHeight = 0;
 
/**
* Taille originale X de l'image
*/
private int imageWidth = 0;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
private String[] infosImages[] = null ;
private int index = 0 ;
 
/**
* true pour animer les transitions
*/
private boolean animerTransition = false;
/**
* Détermine la durée de la transition
*/
private float dureeAnimation = (float) 0.15;
/**
* Booleen d'initalisation général
*/
private boolean initialise = false;
 
/**
* Booleen d'initalisation du conteneur d'image
*/
private boolean conteneurInitialise = false;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ;
com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ;
Image imgAgrandie = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MiniZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer à la vue
*/
public MiniZoomImageVue(ObservationMediateur im) {
super(titrePanneau);
setId("x-view-mini-zoom-panel");
// on associe le médiateur
oMediateur = im;
 
prev.setStylePrimaryName("x-view-zoom-button-p");
suiv.setStylePrimaryName("x-view-zoom-button-s");
 
imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
imgZoom.setConstrain(true);
// on crée une image qui gère le double clic et la roulette de la souris
image = new Image() {
 
@Override
public void onBrowserEvent(Event event) {
 
// lors d'un déplacement de la roulette
if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
 
// on simule un clic sur le bouton précédent
if (event.getMouseWheelVelocityY() >= 1) {
prev.click();
}
 
// ou suivant
if (event.getMouseWheelVelocityY() <= -1) {
suiv.click();
}
}
if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) {
event.preventDefault() ;
int[] xy = {event.getClientX(),event.getClientY()} ;
afficherMenu(xy) ;
}
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
if(imgZoom.isVisible()) {
imgZoom.hide();
} else {
afficherPanneauAgrandi();
}
}
}
};
image.setPixelSize(150, 150);
infosImages = new String[0][0] ;
 
this.setHeader(true);
 
imageConteneur = new Panel() ;
imageConteneur.setBorder(false);
 
imageConteneur.add(image);
imageConteneur.setId("x-view-mini-zoom-img");
 
// il n'existe pas de méthode pour ajouter un listener pour le double
// clic sur une image
// alors on lui dit manuellement de capter l'évènement double clic
image.sinkEvents(Event.ONDBLCLICK);
image.sinkEvents(Event.ONMOUSEWHEEL);
image.sinkEvents(Event.ONCONTEXTMENU) ;
 
// l'image de base est vide
image.setUrl("");
 
this.setLayout(new BorderLayout());
 
prev.setWidth("15%");
suiv.setWidth("15%");
 
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
 
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen qui dit si on doit répnadre l'évènement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit une string
if (nouvelleDonnees instanceof String[][] && initialise
&& conteneurInitialise && ((String[][])nouvelleDonnees).length != 0) {
infosImages = (String[][]) nouvelleDonnees;
index = 0 ;
afficherImage() ;
} else {
// sinon on met une image vide
infosImages = null ;
afficherImage();
}
}
 
public void afficherImage()
{
// c'est l'url de l'image qu'on associe à la vue
if(infosImages != null && infosImages.length != 0)
{
setTitle(titrePanneau+" "+(index+1)+" / "+infosImages.length);
getImage().setUrl(getUrlMiniature(index));
imageWidth = Integer.parseInt(infosImages[index][1]);
imageHeight = Integer.parseInt(infosImages[index][2]);
verifierEtRetaillerImage();
activerPanneau(true);
} else {
setTitle(titrePanneau);
getImage().setUrl("ill_liaison.png");
imageWidth = getImage().getWidth();
imageHeight = getImage().getHeight();
if(imgZoom.isVisible()) {
agrandirImage();
}
activerPanneau(false);
}
if(infosImages != null && infosImages.length > 1) {
prev.setEnabled(true);
suiv.setEnabled(true);
} else {
prev.setEnabled(false);
suiv.setEnabled(false);
}
}
 
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau(boolean activer) {
if(activer) {
this.getEl().unmask();
} else {
this.getEl().mask();
}
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
 
// gestion du clic sur le bouton précedent
prev.addClickHandler(new ClickHandler() {
 
@Override
public void onClick(ClickEvent event) {
if(infosImages.length != 0) {
if(index == 0)
{
index = infosImages.length - 1 ;
}
else
{
index-- ;
}
afficherImage() ;
}
}
 
});
 
// gestion du clic sur le bouton suivant
suiv.addClickHandler(new ClickHandler() {
 
// en cas de clic
@Override
public void onClick(ClickEvent event) {
if(infosImages.length != 0) {
if(index == infosImages.length - 1)
{
index = 0 ;
}
else
{
index++ ;
}
afficherImage() ;
}
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ObservationMediateur getIMediateur() {
return oMediateur;
}
 
/**
* Accesseur au conteneur de l'image
*
* @return le conteneur de l'image
*/
public Image getImage() {
return image;
}
/**
* Acesseurs pour l'identifiant de l'image
* @return l'id de l'image
*/
public String getIdImage()
{
return infosImages[index][0] ;
}
 
/**
* Accesseur pour le bouton précédent
*
* @return le bouton précédent
*/
public com.google.gwt.user.client.ui.Button getPrev() {
return prev;
}
 
/**
* Accesseur pour le bouton suivant
*
* @return le bouton suivant
*/
public com.google.gwt.user.client.ui.Button getSuiv() {
return suiv;
}
 
/**
* Setter pour la taille de l'image
*
* @param x
* la largeur en pixels
* @param y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y) {
imageHeight = y;
imageWidth = x;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
idImage = id ;
}
 
/**
* renvoie la taille originale de l'image
*
* @return un tableau de deux entiers contenant la largeur puis la hauteur
*/
public int[] getTailleImage() {
int[] taille = { imageHeight, imageWidth };
 
return taille;
}
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
 
return imageConteneur;
 
}
 
public void raz() {
infosImages = new String[0][0] ;
getImage().setUrl("");
}
public void supprimerLiaisonImage() {
if(infosImages.length > 0) {
getImage().setUrl("") ;
int nouvelleTaille = infosImages.length - 1 ;
int indexSupp = index ;
String[][] nouveauInfosImages = new String[nouvelleTaille][3] ;
int j = 0 ;
for(int i = 0 ; i < infosImages.length ; i++) {
if(i != indexSupp) {
nouveauInfosImages[j] = infosImages[i] ;
j++ ;
}
}
infosImages = nouveauInfosImages ;
index = 0 ;
afficherImage() ;
}
}
public void afficherMenu(int[] xy) {
Menu mn = new Menu() ;
final Item suppLiaison = new Item("Supprimer la liaison") ;
mn.addItem(suppLiaison) ;
mn.addListener(new MenuListenerAdapter() {
@Override
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'aide
if (item.equals(suppLiaison)) {
// on notifie le médiateur
getIMediateur().supprimerLiaisonObsImage() ;
}
}
}) ;
mn.showAt(xy) ;
}
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
int[] dim = calculerDimensions(getTailleImage(),300,imageConteneur.getWidth());
getImage().setSize("" + dim[0] + "px",
"" + dim[1] + "px");
doLayout();
if(imgZoom.isVisible()) {
agrandirImage();
}
}
public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {(int)Math.round(XYresize[0]*0.85),(int)Math.round(XYresize[1]*0.85)} ;
return res;
}
protected void agrandirImage() {
String urlAgrandie = "";
if(infosImages == null) {
urlAgrandie = "ill_liaison.png";
setTailleImage(265, 270);
} else {
urlAgrandie = getUrlAgrandie(index);
}
if(imgAgrandie == null) {
imgAgrandie = new Image(urlAgrandie);
imgZoom.add(imgAgrandie);
imgAgrandie.addLoadHandler(new LoadHandler() {
 
@Override
public void onLoad(LoadEvent event) {
int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75);
ExtElement imgElement = Ext.get(imgAgrandie.getElement());
if(animerTransition) {
AnimationConfig a = new AnimationConfig() ;
a.setDuration(dureeAnimation);
imgElement.setHeight(tailleImage[1], a);
imgElement.setWidth(tailleImage[0], a);
ExtElement winElement = Ext.get(imgZoom.getElement());
winElement.setHeight(tailleImage[1], a);
winElement.setWidth(tailleImage[0], a);
} else {
imgElement.setHeight(tailleImage[1], false);
imgElement.setWidth(tailleImage[0], false);
ExtElement winElement = Ext.get(imgZoom.getElement());
winElement.setHeight(tailleImage[1], false);
winElement.setWidth(tailleImage[0], false);
}
}
});
} else {
imgAgrandie.setUrl(urlAgrandie);
imgAgrandie.setVisible(true);
}
}
private String getUrlMiniature(int index) {
String[][] paramsImage = {{"id_image",infosImages[index][0]}};
ImageCarnet ic = new ImageCarnet(paramsImage);
return ic.getUrlFormatGalerie();
}
private String getUrlAgrandie(int index) {
String[][] paramsImage = {{"id_image",infosImages[index][0]}};
ImageCarnet ic = new ImageCarnet(paramsImage);
return ic.getUrlFormatZoom();
}
private void afficherPanneauAgrandi() {
agrandirImage();
imgZoom.show(this.getElement());
imgZoom.setPosition((int)(Window.getClientWidth() - Window.getClientWidth()*0.50),(int)(Window.getClientHeight() - Window.getClientHeight()*0.85));
}
}
 
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java
New file
0,0 → 1,209
package org.tela_botanica.client.vues.observation.indicateurs;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
 
/**
* Un panneau affichant la repartition d'une plante
*
* @author David Delon
*
*/
public class InformationRepartitionVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* l'image à afficher
*/
private Image image = new Image();
private String urlImage = "" ;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ;
com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private InformationRepartitionVue() {
super();
}
 
/**
* Constructeur avec argument
* @param obs le médiateur à associer
*/
public InformationRepartitionVue(ObservationMediateur obs) {
this.observationMediateur = obs;
imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
image = new Image() {
 
@Override
public void onBrowserEvent(Event event) {
 
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
 
// on notifie le médiateur
agrandirImage() ;
}
}
};
tp.applyTo(image.getElement()) ;
image.sinkEvents(Event.ONDBLCLICK);
imgZoom.setConstrain(true);
imgZoom.setAutoHeight(true) ;
imgZoom.setAutoWidth(true) ;
this.setCls("x-image-info-rep") ;
add(image);
image.setPixelSize(150, 150);
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Affichage carte de repartition
*
*/
@Override
public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {
 
// si on recoit une String contenant une URL
if (nouvelleDonnees instanceof String) {
urlImage=(String) nouvelleDonnees;
if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) {
image.setUrl("ill_choro.png") ;
image.setPixelSize(150, 150);
}
else {
image.setUrl(urlImage);
verifierEtRetaillerImage();
}
}
}
public void agrandirImage() {
if(!imgZoom.isVisible())
{
String urlAgrandie = urlImage.replace("min", "max") ;
imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlAgrandie+"\" />") ;
imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ;
imgZoom.show(this.getElement()) ;
} else {
imgZoom.hide();
}
}
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
 
// on prend la taille originale de l'image
int originalX = image.getWidth();
int originalY = image.getHeight();
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = getWidth();
int tailleConteneurY = getHeight();
int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
int max = Math.min(maxConteneur, 300);
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
// si la longueur de l'image est la plus grande des deux
int maxImage = Math.max(originalX, originalY);
if(maxImage == originalX) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = max;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
}
else
{
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = max;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
image.setPixelSize(nouvelleTailleX ,
nouvelleTailleY);
doLayout();
}
 
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
}
public void raz() {
image.setUrl("");
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java
New file
0,0 → 1,215
package org.tela_botanica.client.vues.observation.indicateurs;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
 
/**
* Un panneau affichant une image generique provenant d eflore
*
* @author David Delon
*
*/
public class ImageGeneriqueVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* l'image à afficher
*/
private Image image = new Image();
private String urlImage = "" ;
private String urlImageMax = "" ;
private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ImageGeneriqueVue() {
super();
}
 
/**
* Constructeur avec argument
* @param obs le médiateur à associer
*/
public ImageGeneriqueVue(ObservationMediateur obs) {
this.observationMediateur = obs;
imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
image = new Image() {
 
@Override
public void onBrowserEvent(Event event) {
 
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
 
// on notifie le médiateur
agrandirImage() ;
}
}
};
tp.applyTo(image.getElement()) ;
this.setCls("x-image-gen") ;
imgZoom.setConstrain(true);
imgZoom.setAutoHeight(true) ;
imgZoom.setAutoWidth(true) ;
 
add(image);
image.setPixelSize(150, 150);
image.sinkEvents(Event.ONDBLCLICK);
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Affichage image generique
*
*/
@Override
public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {
 
// si on recoit une String contenant une URL
if (nouvelleDonnees instanceof String []) {
String [] lecteurDonnees = (String []) nouvelleDonnees;
urlImage=lecteurDonnees[0];
urlImageMax=lecteurDonnees[1];
if (urlImage == null || urlImage.equals("null") || urlImage.length()==0 || urlImage.equals("")) {
image.setUrl("ill_taxon.png") ;
image.setPixelSize(150, 150);
}
else {
image.setUrl(urlImage);
verifierEtRetaillerImage();
}
} else {
image.setUrl("ill_taxon.png") ;
image.setPixelSize(150, 150);
}
observationMediateur.deMasquerChargementInfosObservations() ;
}
public void agrandirImage() {
if(!imgZoom.isVisible())
{
imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlImageMax+"\" />") ;
imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ;
imgZoom.show(this.getElement()) ;
} else {
imgZoom.hide();
}
 
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
}
public void raz() {
image.setUrl("");
}
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
 
// on prend la taille originale de l'image
int originalX = image.getWidth();
int originalY = image.getHeight();
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = getWidth();
int tailleConteneurY = getHeight();
int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
int max = Math.min(maxConteneur, 300);
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
// si la longueur de l'image est la plus grande des deux
int maxImage = Math.max(originalX, originalY);
if(maxImage == originalX) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = max;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
}
else
{
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = max;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
image.setPixelSize(nouvelleTailleX ,
nouvelleTailleY);
doLayout();
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java
New file
0,0 → 1,86
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.observation.ObservationMediateur;
import com.google.gwt.user.client.ui.FileUpload;
import com.google.gwt.user.client.ui.FormPanel;
import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteEvent;
import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteHandler;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.HasAlignment;
import com.google.gwt.user.client.ui.HasHorizontalAlignment;
import com.google.gwt.user.client.ui.Hidden;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
 
public class FormulaireImportObservationVue {
private ObservationMediateur oMediateur = null;
private Window nPan = null;
private Hidden identifiant = null;
public FormulaireImportObservationVue(ObservationMediateur om) {
this.oMediateur = om;
 
nPan = new Window("Import d'observations");
identifiant = new Hidden();
identifiant.setName("utilisateur");
identifiant.setValue(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
final FormPanel form = new FormPanel();
final Button boutonValidation = new Button("envoyer");
form.setEncoding(FormPanel.ENCODING_MULTIPART);
form.setMethod(FormPanel.METHOD_POST);
form.setWidth("275px");
nPan.setWidth("275px");
 
VerticalPanel holder = new VerticalPanel();
 
FileUpload upload = new FileUpload();
upload.setName("upload");
holder.add(upload);
holder.add(boutonValidation);
holder.add(identifiant);
HTML lienVersDocumentModele = new HTML("<a href=\"modele_import.xls\">Télécharger le modèle de document</a>");
holder.add(lienVersDocumentModele);
 
holder.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
boutonValidation.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
form.submit();
}
});
 
form.add(holder);
nPan.add(form);
form.setAction(Configuration.getServiceBaseUrl() + "/ImportXLS");
form.addSubmitCompleteHandler(new SubmitCompleteHandler() {
@Override
public void onSubmitComplete(SubmitCompleteEvent event) {
nPan.close();
// TODO: le résultat est du texte, mais à l'avenir il faudrait utiliser du JSON
com.google.gwt.user.client.Window.alert(event.getResults());
oMediateur.obtenirDernierePageObservation();
}
});
}
public void afficher() {
nPan.show();
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java
New file
0,0 → 1,1003
package org.tela_botanica.client.vues.observation;
 
 
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Ontologies;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.BarrePaginationVue;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
 
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.SortDir;
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.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SortState;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDropConfig;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Tool;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.event.GridHeaderListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter;
import com.gwtext.client.widgets.tree.TreeDragData;
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
* Liste d'observation composée de ligne d'observation
* l'interface rafraichissable et l'interface vueListable
*
* @author David Delon 2008
*/
public class ListeObservationVue extends GridPanel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
/**
* Config de colonne
*/
private ColumnConfig etatObservation;
private ColumnConfig referentielTaxoObservation;
private ColumnConfig nomSaisiObservation;
private ColumnConfig nomRetenuObservation;
private ColumnConfig familleObservation;
private ColumnConfig lieuObservation;
private ColumnConfig altitudeObservation;
private ColumnConfig dateObservation;
private ColumnConfig ordreObservation;
private ColumnConfig abondanceObservation;
private ColumnConfig certitudeObservation;
private ColumnModel modeleColonnes;
 
/**
* Store qui contient les données à afficher
*/
private Store st = null;
/**
* Barre de pagination
*/
private BarrePaginationVue bt = null ;
/**
* Numéro de page en cours
*/
private int pageEncours = 0 ;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Taille de page (par défaut 20)
*/
private int taillePage = 20 ;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
private ListeObservation cacheListeObservation = null;
private Tool exporterObservations = null ;
private final int KEY_ENTER = 13;
private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION";
 
 
private boolean tailleInitialisee = false ;
 
private ColumnConfig phenologieObservation;
 
private SortDir directionTri;
 
private String champTri;
private boolean triActif;
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ListeObservationVue()
{
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur à associer
*/
public ListeObservationVue(ObservationMediateur obs) {
this.observationMediateur = obs;
setId("x-list-obs");
setHeader(true);
// on place la barre de pagination
bt = new BarrePaginationVue(this);
bt.setLabelElement("Observations");
bt.setTaillePageParDefaut(20);
bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ;
Toolbar barreActions = new Toolbar();
ToolbarButton publier = new ToolbarButton("Rendre publiques");
publier.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button b, EventObject e) {
observationMediateur.transmettreObservations(true);
}
});
ToolbarButton privatiser = new ToolbarButton("Rendre privées");
privatiser.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button b, EventObject e) {
observationMediateur.transmettreObservations(false);
}
});
ToolbarButton supprimer = new ToolbarButton("Supprimer");
supprimer.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button b, EventObject e) {
observationMediateur.supprimerObservations();
}
});
ToolbarButton importer = new ToolbarButton("Importer");
importer.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button b, EventObject e) {
observationMediateur.afficherFormulaireImportObservation();
}
});
ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>");
ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"Export des noms communs, des champs étendus, des données baseflor et des syntaxon baseveg\"> Export Étendu </a>");
ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"Génération d'étiquettes au format PDF pour la sélection\"> Étiquettes </a>");
barreActions.addButton(publier);
barreActions.addButton(privatiser);
barreActions.addSpacer();
barreActions.addButton(supprimer);
barreActions.addSpacer();
barreActions.addButton(importer);
barreActions.addSpacer();
barreActions.addItem(exporter);
barreActions.addItem(exporterFull);
barreActions.addItem(exporterPDF);
this.setTopToolbar(barreActions) ;
this.setBottomToolbar(bt);
this.setCollapsible(true);
this.setTitleCollapse(true);
 
this.setTitle("Observations") ;
modeleColonnes = new ColumnModel(getConfigColonnes());
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
this.setEnableColumnResize(true);
// creation du store
RecordDef rd = new RecordDef(getDefinitionChamps());
st = new Store(rd);
 
// on associe le store
this.setStore(st);
this.getView().setAutoFill(true);
this.getView().setForceFit(true) ;
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("Chargement");
// on ajoute les listeners
ajouterListeners();
configDragAndDrop();
 
}
private ColumnConfig[] getConfigColonnes() {
// on construit le modèle de colonnes
// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir)
Renderer colRend = new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
String valeur = "";
if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) {
valeur = value.toString() ;
}
return valeur;
}
} ;
Renderer dateRend = new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
return "" ;
}
else
{
String dateEntiere = value.toString() ;
String[] dateEtHeure = dateEntiere.split(" ", 2);
if(verifierFormatDate(dateEtHeure[0])) {
String[] dateFormateeTab = dateEtHeure[0].split("-",3);
return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;
}
}
return value.toString() ;
}
} ;
etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
if(value.equals("1"))
{
return "<img src=\"tela.png\"/></img>" ;
}
else
{
return "" ;
}
}
});
referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend);
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend);
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend);
familleObservation = new ColumnConfig("Famille", "famille_observation", 50, true, colRend);
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend);
altitudeObservation = new ColumnConfig("Alt", "altitude_observation", 10, true, colRend);
dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend);
abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend);
certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() {
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude"));
}
});
phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend);
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend);
ColumnConfig[] cm = {etatObservation, referentielTaxoObservation,
nomSaisiObservation, certitudeObservation,
nomRetenuObservation, familleObservation,
abondanceObservation, phenologieObservation,
lieuObservation, altitudeObservation,
dateObservation, ordreObservation};
return cm;
}
 
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
this.addGridHeaderListener(new GridHeaderListenerAdapter() {
@Override
public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
triActif = true;
Timer t = new Timer() {
@Override
public void run() {
enregistrerEtatTri();
observationMediateur.obtenirListeObservation();
}
};
t.schedule(200);
}
});
this.addGridRowListener(new GridRowListenerAdapter() {
// gestion du clic sur une ligne
@Override
public void onRowClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur et on lui passe le numéro de ligne
Record rd = st.getAt(rowIndex);
String ordreObservation = rd.getAsString("ordre_observation") ;
observationMediateur.onClicListeObservation(rowIndex,ordreObservation);
}
 
// gestion du clic droit
@Override
public void onRowContextMenu(GridPanel grid, int rowIndex,
EventObject e) {
// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
e.stopEvent() ;
// on notifie le médiateur en lui passant l'évenement
observationMediateur.montrerContextMenu(e);
}
 
// gestion du double clic
@Override
public void onRowDblClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur en lui passant le numéro de ligne
observationMediateur.doubleClicListeObservation(rowIndex);
}
});
this.addGridListener(new GridListenerAdapter() {
@Override
public void onKeyPress(EventObject e) {
if(e.getKey() == KEY_ENTER) {
Record rd = getSelectionModel().getSelected();
int rowIndex = st.indexOf(rd);
String ordreObservation = rd.getAsString("ordre_observation") ;
observationMediateur.onClicListeObservation(rowIndex, ordreObservation);
}
}
});
this.addListener(new PanelListenerAdapter() {
@Override
public void onRender(Component c) {
ExtElement lienExport = Ext.get("lienExport") ;
lienExport.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
observationMediateur.exporterObservations("xls", "standard");
}
});
 
ExtElement lienExportFull = Ext.get("lienExportFull") ;
lienExportFull.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
observationMediateur.exporterObservations("xls", "standard,avance,etendu,baseflor");
}
});
 
ExtElement lienExportPDF = Ext.get("lienExportPDF") ;
lienExportPDF.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
observationMediateur.exporterObservationsPDF();
}
});
}
});
this.addListener(new PanelListenerAdapter() {
@Override
public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) {
doLayout();
}
});
}
/**
* Configure le drag 'n drop pour la liste
*/
private void configDragAndDrop()
{
 
setDdGroup("ObsMotsClesGroup");
setEnableDragDrop(true);
setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier");
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("ObsMotsClesGroup");
dtc.setTarget(true);
DragDropConfig ddc = new DragDropConfig();
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
@Override
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si on reçoit des données provenant d'un arbre
// on les convertit
if(data instanceof TreeDragData) {
TreeDragData tdd = (TreeDragData)data ;
TreeNode treeNode = tdd.getTreeNode();
String idMc = treeNode.getId();
int index = getView().findRowIndex(e);
if(index < 0) {
return true;
}
Record obsRd = getStore().getRecordAt(index);
if(obsRd == null) {
return true;
}
String ordreObs = obsRd.getAsString("ordre_observation");
if(ordreObs != null) {
observationMediateur.gererDDMotCleSurObs(ordreObs, idMc);
return true ;
} else {
return true;
}
}
return true;
}
@Override
public String notifyOver(DragSource source, EventObject e, DragData data){
if(data instanceof TreeDragData) {
TreeDragData tdd = (TreeDragData)data ;
TreeNode treeNode = tdd.getTreeNode();
String idMc = treeNode.getId();
int index = getView().findRowIndex(e);
if(index < 0) {
return "x-dd-drop-nodrop";
}
Record obsRd = getStore().getRecordAt(index);
if(obsRd == null) {
return "x-dd-drop-nodrop";
}
String ordreObs = obsRd.getAsString("ordre_observation");
if(ordreObs != null) {
return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc);
}
}
return "x-dd-drop-nodrop";
}
};
}
 
/**
* Méthode héritée de l'interface VueListable
* Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres
*/
@Override
public String[] getIdSelectionnees() {
Record[] selection = this.getSelectionModel().getSelections();
int taille = selection.length;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("ordre_observation");
}
 
return id_selection;
}
 
/**
* Sélectionne des enregistrements donné
* @param sel un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
getSelectionModel().clearSelections();
getSelectionModel().selectRecords(sel);
}
/**
* Accesseur pour la toolbar de pagination
* @return la toolbar de pagination
*/
public BarrePaginationVue getToolBarVue()
{
return bt ;
}
 
 
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
if (masked!=null) {
masked.mask("Chargement") ;
}
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
masked.unmask() ;
}
}
/**
* Méthode héritée de l'interface rafraichissable
* @param nouvelleDonnees les nouvelles données
* @param repandreRafraichissement le booleen de notification du rafraichissement
*/
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
// si l'on a reçu une liste d'observation
if(nouvelleDonnees instanceof ListeObservation)
{
ListeObservation data = (ListeObservation) nouvelleDonnees ;
Object[][] observationData = new Object[data.size()][13];
int i = 0 ;
if(data.size() == 0)
{
pageEncours = 0 ;
}
// on la parse et on récupère les informations qui nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=data.get(it.next());
observationData[i][0] = obs.getTransmis();
observationData[i][1] = obs.getCodeCourtReferentielTaxo();
observationData[i][2] = obs.getNomSaisi();
observationData[i][3] = obs.getCertitude();
observationData[i][4] = obs.getNomRetenu();
observationData[i][5] = obs.getFamille();
observationData[i][6] = obs.getAbondance();
observationData[i][7] = obs.getPhenologie();
observationData[i][8] = Util.formaterLieu(obs, modeleLieu);
observationData[i][9] = formaterAltitude(obs.getAltitude());
observationData[i][10] = obs.getDate();
observationData[i][11] = obs.getNumeroOrdre();
observationData[i][12] = obs.getNumeroNomenclaturalSaisi();
i++ ;
}
RecordDef rd = new RecordDef(getDefinitionChamps());
final MemoryProxy dataProxy = new MemoryProxy(observationData);
final ArrayReader reader = new ArrayReader(rd);
final Store observationStore = new Store(dataProxy, reader);
st = observationStore ;
st.load() ;
// et on reconfigure et rafraichit la vue
this.reconfigure(st, this.getColumnModel());
demasquerChargement();
cacheListeObservation=data;
observationMediateur.onRafraichissementListeObservations();
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'observation 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
changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
if(nbElements > 0) {
masquerChargement();
observationMediateur.obtenirListeObservation(this);
} else {
this.rafraichir(new ListeObservation(0), false);
}
}
// si l'on a reçu une Observation
if(nouvelleDonnees instanceof Observation) {
// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
// on l'enregistre donc avant suppression
enregistrerEtatTri();
Observation obs= (Observation) nouvelleDonnees;
if (obs.getNumeroOrdre()==null) {
// Nouvelle observation
// On affiche la dernière page
pageEncours = pageMax ;
masquerChargement();
observationMediateur.obtenirNombreObservation();
}
else { // Modification d'une observation
masquerChargement();
observationMediateur.obtenirNombreObservation();
}
}
// Si on a effectué une suppression
if(nouvelleDonnees instanceof String)
{
// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri
// on l'enregistre donc avant suppression
enregistrerEtatTri();
observationMediateur.obtenirNombreObservation() ;
}
if(!getTailleInitialisee()) {
if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
doLayout();
setTailleInitialisee();
}
}
// réaffectation du tri courant si nécessaire
if(directionTri != null && champTri != null) {
st.sort(champTri, directionTri);
}
}
private String formaterAltitude(String alt) {
String alfFmt = Util.formaterNombre(alt);
if(!alfFmt.isEmpty() && !Util.estZero(alfFmt)) {
alfFmt = alfFmt+" m.";
}
return alfFmt;
}
private FieldDef[] getDefinitionChamps() {
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defCertitudeObservation = new StringFieldDef("certitude");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defFamilleObservation = new StringFieldDef("famille_observation");
FieldDef defAbondanceObservation = new StringFieldDef("abondance");
FieldDef defPhenologieObservation = new StringFieldDef("phenologie");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defAltObservation = new StringFieldDef("altitude_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
// Non affiches :
FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
 
FieldDef[] defTab = {defEtatObservation, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defFamilleObservation, defAbondanceObservation,
defPhenologieObservation, defLieuObservation, defAltObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };
return defTab;
}
// GESTION DE LA PAGINATION
public ListeObservation getCacheListeObservation() {
return cacheListeObservation;
}
 
/**
* 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) arrondi à l'entier superieur
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
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) ;
return Math.abs(nPageInt.intValue()) ;
}
/**
* Appelle le modèle pour lui demander les données d'une page à afficher
* @param pageCourante le numéro de page à affciher
*/
@Override
public void changerNumeroPage(int pageCourante) {
pageEncours = pageCourante ;
masquerChargement();
enregistrerEtatTri();
// On lance le chargerment des observations
observationMediateur.obtenirNombreObservation();
getToolBarVue().changerPageCourante(pageCourante);
}
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
@Override
public void changerTaillePage(int nouvelleTaillePage) {
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
enregistrerEtatTri();
 
masquerChargement();
 
// On lance le chargement des observations
observationMediateur.obtenirNombreObservation();
// et on met à jour la taille de page dans les barres d'outils
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} ;
getToolBarVue().rafraichir(pages, false) ;
}
/**
* Renvoie la taille de page en cours d'utilisation
* @return la taille de page
*/
public int getTaillePage() {
return taillePage;
}
/**
* Renvoie le numéro de la page encours (attention on commence à 0)
* @return le numéro de la page en cours
*/
public int getPageEncours() {
return pageEncours;
}
private void enregistrerEtatTri() {
if(triActif) {
this.directionTri = st.getSortState().getDirection();
this.champTri = st.getSortState().getField();
}
}
public void afficherFiltres(String[][] filtresEnCours) {
String texteFiltresEnCours = "";
for(int i = 0; i < filtresEnCours.length; i++) {
if(Util.filtreValide(filtresEnCours[i])) {
if(!texteFiltresEnCours.equals("")) {
texteFiltresEnCours += " - ";
}
texteFiltresEnCours += "<span class=\"affichage_filtre\">"+
transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+
" <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+
"</span>";
}
}
if(!texteFiltresEnCours.equals("")) {
texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>";
}
this.setTitle("Observations"+texteFiltresEnCours) ;
for(int i = 0; i < filtresEnCours.length; i++) {
if(Util.filtreValide(filtresEnCours[i])) {
if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) {
Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
e.stopEvent();
observationMediateur.viderFiltre(e.getTarget().getAttribute("rel"));
}
});
}
}
}
}
private String transformerNomFiltre(String nomFiltre) {
if(nomFiltre.equals("departement")) {
nomFiltre = "departement";
}
if(nomFiltre.equals("commune")) {
nomFiltre = "commune";
}
if(nomFiltre.equals("nom_taxon")) {
nomFiltre = "recherche";
}
if(nomFiltre.equals("id_mots_cles")) {
nomFiltre = "projets";
}
return nomFiltre;
}
private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) {
String valeurFiltreTransformee = valeurFiltre;
if(nomFiltre.equals("id_mots_cles")) {
String[] tabMotsCles = valeurFiltre.split(";");
String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles);
if(tabMotsClesTexte.length > 1) {
valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte);
} else {
valeurFiltreTransformee = tabMotsClesTexte[0];
}
}
if(nomFiltre.equals("mois")) {
valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre));
}
valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue");
valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue");
valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue");
 
return valeurFiltreTransformee;
}
 
public void raz() {
RecordDef rd = new RecordDef(getDefinitionChamps());
st = new Store(rd);
// on associe le store
this.setStore(st);
}
public boolean verifierFormatDate(String date) {
String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
if(date.matches(regex) && !date.equals("0000-00-00")) {
return true ;
}
else {
return false;
}
}
public boolean getTailleInitialisee() {
return tailleInitialisee ;
}
public void setTailleInitialisee() {
tailleInitialisee = true;
}
 
public String renvoyerTri() {
String tri = "ordre";
if(triActif) {
HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri();
if(corr.containsKey(champTri)) {
tri = corr.get(champTri);
}
}
return tri;
}
 
public String renvoyerDirectionTri() {
try {
return (triActif) ? directionTri.getDirection() : "ASC";
} catch (Exception e) {
return "ASC";
}
}
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java
New file
0,0 → 1,196
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.form.TextField;
 
public class MotsClesObsVue extends Panel implements Filtrable, Rafraichissable {
private ObservationMediateur oMediateur = null ;
/**
* Barre de recherche
*
*/
private TextField champRecherche = null;
 
/**
* Booleen d'etat du filtre
*/
private boolean filtreModifie = false;
 
/**
* mot(s) à chercher
*/
private String motsAChercher = "";
/**
* bouton de validation
*/
private Button ok = null ;
private Button afficherNuage = null;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private MotsClesObsVue() {
super();
}
 
/**
* Constructeur avec médiateur
*
* @param im
*/
public MotsClesObsVue(ObservationMediateur om) {
super();
oMediateur = om;
 
Label labelRecherche = new Label("Mots clés :");
champRecherche = new TextField();
ok = new Button("Rechercher");
afficherNuage = new Button("Voir les mots clés");
 
add(labelRecherche);
add(champRecherche);
add(ok);
add(afficherNuage);
 
setPaddings(5);
setBorder(false);
setCollapsible(true);
 
ajouterListeners();
}
 
/**
* ajoute des listeners
*/
private void ajouterListeners() {
 
// gestion de la touche entrée
champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() {
 
@Override
public void onKey(int key, EventObject e) {
 
valider();
}
 
});
ok.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
valider();
}
});
afficherNuage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
// oMediateur.afficherNuageMotsCles();
}
});
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
if(nouvelleDonnees instanceof String) {
champRecherche.setValue(champRecherche.getValueAsString()+" "+(String)nouvelleDonnees);
}
filtreModifie = false;
 
}
 
/**
* renvoie l'état du filtre (modifié ou non)
*
* @return l'état du filtre
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
/**
* Renvoie le nom du filtre
*
* @return le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "Recherche Mots clés";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
 
String[] valeurFiltre = new String[0];
if(!motsAChercher.equals("")) {
valeurFiltre = new String[2];
valeurFiltre[0] = "mots_cles";
valeurFiltre[1] = motsAChercher;
}
return valeurFiltre;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ObservationMediateur getIMediateur() {
return oMediateur;
}
 
/**
* Effectue quelque opérations dans la classe et envoie une requête de
* données au médiateur
*/
@Override
public void valider() {
filtreModifie = true;
motsAChercher = champRecherche.getText();
oMediateur.obtenirNombreObservation();
}
 
/**
* Affiche la fenetre
*/
public void afficherFiltre() {
 
champRecherche.setValue(motsAChercher);
}
 
@Override
public void viderFiltre() {
champRecherche.setValue("");
motsAChercher = "";
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java
New file
0,0 → 1,2239
package org.tela_botanica.client.vues.observation;
 
// TODO Detecter redim et supprimer ajuster
 
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
import org.tela_botanica.client.modeles.objets.ChampEtendu;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.ListeReferentielCommune;
import org.tela_botanica.client.modeles.objets.ListeReferentielNom;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Ontologies;
import org.tela_botanica.client.modeles.objets.ReferentielCommune;
import org.tela_botanica.client.modeles.objets.ReferentielNom;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.AutoCompletionRefComboBox;
import org.tela_botanica.client.util.ChampSaisieEtendu;
import org.tela_botanica.client.util.FormulaireSaisieChampEtendu;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.PopupPanel;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.core.Position;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.DatePicker;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.DatePickerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.DateField;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.Label;
import com.gwtext.client.widgets.form.MultiFieldPanel;
import com.gwtext.client.widgets.form.TextArea;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
import com.gwtext.client.widgets.layout.AnchorLayoutData;
import com.gwtext.client.widgets.layout.ColumnLayout;
import com.gwtext.client.widgets.layout.ColumnLayoutData;
import com.gwtext.client.widgets.layout.FormLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.data.Record;
 
/**
* Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il implémente l'interface rafraichissable
* @author aurelien
*
*/
public class FormulaireSaisieObservationVue extends Panel implements Rafraichissable {
 
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
FormPanel panneauFormulaire = null;
 
private DateField date = null;
private ComboBox lieudit = null;
private ComboBox station = null;
private ComboBox milieu = null;
private TextField comment = null;
private ComboBox commune = null;
private String departement = null;
private ComboBox espece = null;
private String numeroNom = null;
private String numeroOrdre = null;
private String codeInseeCommune = null;
private String referentielTaxo = null;
private String referentielGeo = null;
 
// Pour remise a zero partielle lors d'une validation
 
private enum Champs {
DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT, LATITUDE, LONGITUDE, ALTITUDE, ABONDANCE, CERTITUDE, REFERENTIELTAXO, PHENOLOGIE;
 
@Override
public String toString() {
switch(this) {
case DATE:
return "date";
case COMMUNE:
return "commune";
case LIEUDIT:
return "lieu dit";
case STATION:
return "station";
case MILIEU:
return "milieu";
case COMMENT:
return "commentaire";
case ESPECE:
return "espèce";
case LATITUDE:
return "latitude";
case LONGITUDE:
return "longitude";
case ALTITUDE:
return "altitude";
case ABONDANCE:
return "abondance";
case CERTITUDE:
return "identification";
case REFERENTIELTAXO:
return "referentiel";
case PHENOLOGIE:
return "phenologie";
case TOUT:
return "date, commune, lieu dit, station, milieu, espèce, commentaire, latitude, longitude, altitude, abondance, identification, referentiel, phenologie";
}
return TOUT.toString();
}
};
 
private String formatDate = null ;
private Button boutonOK = new Button("Créer");
private Button boutonModifier = new Button("Modifier");
private Button boutonSupprimer = new Button("Supprimer");
private Button boutonAnnuler = new Button("Réinitialiser");
 
private boolean selectionCommune=false;
private boolean selectionEspece=false;
private boolean selectionAbondance = false;
private boolean selectionCertitude = false;
private boolean selectionPhenologie = false;
 
private Toolbar bt = null ;
 
private final String VALEURS_MULTIPLES = "(Valeurs multiples)";
private final String modeleMessageModif = "commune:lieu-dit:station:milieu:latitude:longitude:altitude:date:espece:commentaire:abondance:identification:referentiel:phenologie";
private boolean communeModifiee = false;
private boolean lieuDitModifie = false;
private boolean stationModifiee = false;
private boolean milieuModifie = false;
private boolean dateModifiee = false;
private boolean especeModifiee = false;
private boolean commModifie = false;
private boolean abondanceModifiee = false;
private boolean certitudeModifiee = false;
private boolean referentielTaxoModifie = false;
private boolean phenologieModifiee = false;;
 
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
 
/**
* Booleen d'instanciation
*/
boolean estInstancie = false ;
 
private Panel panneauIntermediaire;
 
private Panel panneauPremierColonne;
 
private Panel panneauSecondeColonne;
 
private TextField longitude;
 
private TextField latitude;
 
private TextField altitude;
 
private MultiFieldPanel htmlCommunePanel = null;
 
private MultiFieldPanel coordPanel;
 
private TextField coordonnees;
 
private Label lienSelectionCommune = null;
 
private HTML afficherFormulaireLatLon;
 
private HTML basculerverscarto;
 
private boolean longlatAjoutee;
 
private boolean latModifiee;
 
private boolean longModifiee;
 
private boolean altModifiee;
 
protected boolean rechercheCommuneEnCours = false;
 
private Timer tCoord;
 
final String resultTplRefPerso = "<div class=\"search-item-commune\">{element_referentiel}</div>";
 
private ComboBox selecteurAbondance = null;
 
private ComboBox selecteurCertitude = null;
 
private ComboBox selecteurReferentielTaxo = null;
 
private ComboBox selecteurStadePheno = null;
 
private boolean selectionMultiple = false;
 
private HTML lienAfficherChampsEtendus = null;
private HTML lienAjouterChampsEtendus = null;
 
Panel conteneurChampEtenduGauche = null;
Panel conteneurChampEtenduDroite = null;
 
private boolean afficherChampsEtendus = false;
private boolean afficherLienAjoutChampsEtendus = false;
private boolean premierAffichage = true;
 
private PopupPanel popUpAjoutChampEtendu = new PopupPanel();
private Map<String, ChampSaisieEtendu> listeChampsEtendus;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private FormulaireSaisieObservationVue()
{
super() ;
}
 
/**
* Constructeur avec argument
* @param im
*/
public FormulaireSaisieObservationVue(ObservationMediateur obs)
{
super("Saisie");
// on associe le médiateur
observationMediateur = obs ;
 
referentielTaxo = obs.getRefTaxSelectionne().getCode();
panneauFormulaire = new FormPanel(Position.RIGHT);
panneauFormulaire.setBorder(false);
 
// Panneau intermediaire qui contient deux colonnes de formulaire
panneauIntermediaire = new Panel();
 
if (Window.getClientWidth()> Window.getClientHeight()) {
panneauIntermediaire.setLayout(new ColumnLayout());
}
else {
panneauIntermediaire.setLayout(new RowLayout());
}
 
panneauIntermediaire.setBorder(false);
 
//création du panneau formulaire de gauche auquels on ajoute les champs
panneauPremierColonne = new Panel();
panneauPremierColonne.setLayout(new FormLayout());
panneauPremierColonne.setBorder(false);
 
//création du panneau formulaire de droite
panneauSecondeColonne = new Panel();
panneauSecondeColonne.setLayout(new FormLayout());
panneauSecondeColonne.setBorder(false);
 
this.setPaddings(5) ;
 
// Accesskey pour debugging
commune = new ComboBox("Commune","commune\" accesskey=\"1");
 
final String resultTplCommune = "<div class=\"search-item-commune\">{commune}</div>";
commune.setTpl(resultTplCommune);
commune.setMode(ComboBox.REMOTE);
commune.setItemSelector("div.search-item-commune");
commune.setTypeAhead(true);
commune.setLoadingText("Recherche...");
commune.setHideTrigger(true);
 
//création du lien "Accès carto" dans le formulaire
basculerverscarto = new HTML(" <a id=\"lien_carto\" href=\"#\" tabindex=\"2\">Localiser la commune</a>");
basculerverscarto.addStyleName("lien_actif");
 
//création info bulle sur le lien "accès carto"
ToolTip tip2 = new ToolTip();
tip2.setHtml("Via une carte, obtenez les coordonnées (latitude/longitude) de votre observation ");
tip2.applyTo(basculerverscarto.getElement());
 
//Sur une meme ligne, ajout de plusieurs champs
htmlCommunePanel = new MultiFieldPanel();
 
int largeurCommune = Window.getClientWidth()/4;
htmlCommunePanel.addToRow(commune, largeurCommune);
htmlCommunePanel.addToRow(basculerverscarto, 160);
 
htmlCommunePanel.setBorder(false);
htmlCommunePanel.setId("x-commune-panel");
 
panneauPremierColonne.add(htmlCommunePanel);
 
station = new AutoCompletionRefComboBox("Station", "station", observationMediateur, TypesReferentiels.REFERENTIEL_STATION) {
 
@Override
public void onModificationValeur() {
stationModifiee = true;
}
 
@Override
public void onValidationSaisie() {
validerSaisie(Champs.STATION);
}
};
panneauPremierColonne.add(station, new AnchorLayoutData("95%"));
 
latitude = new TextField("Lat", "lat");
latitude.setGrowMax(70);
latitude.setAllowBlank(true);
 
longitude = new TextField("Lon", "lon");
longitude.setGrowMax(70);
longitude.setAllowBlank(true);
 
altitude = new TextField("Alt (mètres)", "alt");
altitude.setGrowMax(70);
altitude.setAllowBlank(true);
 
lienSelectionCommune = new Label("");
 
 
lienSelectionCommune.setId("conteneur_selection_commune");
lienSelectionCommune.setStyleName("conteneur_selection_commune");
lienSelectionCommune.addStyleName("lien_actif");
 
// Panneau de type plusieurs champs de formulaire sur une meme ligne, où seront renseignés Lat/Lon
coordPanel = new MultiFieldPanel();
coordPanel.setPaddings(0, 0, 0, 10);
coordPanel.setVisible(false);
 
final double largeur ;
largeur = 120;
 
coordPanel.addToRow(latitude, new ColumnLayoutData(largeur));
coordPanel.addToRow(longitude, new ColumnLayoutData(largeur));
coordPanel.addToRow(lienSelectionCommune, new ColumnLayoutData(largeur));
lienSelectionCommune.addClass("lien_decale");
coordPanel.setBorder(false);
 
coordPanel.addToRow(altitude, new ColumnLayoutData(largeur));
 
//création du champs coordonnées
referentielGeo = Configuration.getReferentielGeo();
 
coordonnees = new TextField("Coordonnées", "", 0);
coordonnees.setMaxLength(0);
coordonnees.setReadOnly(true);
coordonnees.setCls("fieldname");
 
//création du lien "saisie X/Y" dans le formulaire
afficherFormulaireLatLon = new HTML("<span style=\"padding-left:30px;\" class=\"conteneur_lien_afficher_lat_lon\">" +
"<a title=\"Lat / Lon sont les latitudes / longitudes, à remplir en degrés décimaux\" class=\"lien_actif\" id=\"lien_coord\" href=\"#\" tabindex=\"6\">Saisie Lat/Lon ("+referentielGeo+")</a>" +
"<span><span style=\"padding-left:20px\" class=\"conteneur_lien_localiser_lat_lon\">"+
"<a title=\"Cliquez pour obtenir les coordonnées de votre observation à partir de la carte\" class=\"lien_actif\" id=\"lien_carto_coord\" href=\"#\" tabindex=\"7\">Localiser sur la carte</a>"+
"</span>");
 
//ajout d'un listener sur le lien "saisie X/Y"
coordPanel.addListener(new PanelListenerAdapter() {
 
@Override
public void onAfterLayout(Container c) {
surPremierAffichageCoordPanel(largeur);
}
});
 
//Sur une meme ligne, ajout de plusieurs champs
final MultiFieldPanel htmlPanel = new MultiFieldPanel();
 
htmlPanel.addToRow(coordonnees, 100);
htmlPanel.addToRow(afficherFormulaireLatLon, new ColumnLayoutData(0.9));
htmlPanel.setBorder(false);
htmlPanel.setId("x-coord-panel");
 
panneauPremierColonne.add(htmlPanel);
panneauPremierColonne.add(coordPanel);
 
date = new DateField("Date", "date", 250);
date.setAllowBlank(true);
formatDate = "d/m/Y";
date.setFormat(formatDate) ;
date.setTitle("Date de l'observation au format jj/mm/aaaa");
date.setMaxValue(new Date());
//date.setTabIndex(5);
panneauPremierColonne.add(date, new AnchorLayoutData("55%"));
 
final String champsListeTpl = "<div class=\"x-combo-list-item search-item-tpl\" title=\"{label}\">{label}</div>";
// Selection d'un référentiel par défaut (le premier spécifié dans la config)
referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode();
selecteurReferentielTaxo = new ComboBox();
selecteurReferentielTaxo.setCls("champ-separation");
selecteurReferentielTaxo.setLabel("Référentiel");
selecteurReferentielTaxo.setStore(Ontologies.getValeursReferentiel());
selecteurReferentielTaxo.setValue(referentielTaxo);
selecteurReferentielTaxo.setDisplayField("label") ;
selecteurReferentielTaxo.setValueField("valeur");
selecteurReferentielTaxo.setEditable(false);
selecteurReferentielTaxo.setHideTrigger(false);
selecteurReferentielTaxo.setForceSelection(true);
selecteurReferentielTaxo.setTpl(champsListeTpl);
espece=new ComboBox("Espèce","nom");
final String resultTplEspece = "<div class=\"search-item-espece {indicateurNomRetenu}\">{nom}</div>";
 
 
espece.setTpl(resultTplEspece);
espece.setMode(ComboBox.REMOTE);
espece.setItemSelector("div.search-item-espece");
espece.setTypeAhead(true);
espece.setLoadingText("Recherche...");
 
espece.setHideTrigger(true);
 
Panel panelSeparationPp = new Panel();
panelSeparationPp.setHeight(15);
panelSeparationPp.setBorder(false);
 
panneauPremierColonne.add(panelSeparationPp);
panneauPremierColonne.add(selecteurReferentielTaxo, new AnchorLayoutData("85%"));
panneauPremierColonne.add(espece, new AnchorLayoutData("95%"));
 
selecteurAbondance = new ComboBox();
selecteurAbondance.setCls("champ-separation");
selecteurAbondance.setLabel("Abondance");
selecteurAbondance.setStore(Ontologies.getValeursAbondance());
selecteurAbondance.setDisplayField("label") ;
selecteurAbondance.setValueField("valeur");
selecteurAbondance.setEditable(true);
selecteurAbondance.setHideTrigger(false);
selecteurAbondance.setForceSelection(false);
selecteurAbondance.setTpl(champsListeTpl);
panneauPremierColonne.add(selecteurAbondance, new AnchorLayoutData("95%"));
lieudit = new AutoCompletionRefComboBox("Lieu-dit", "lieudit",observationMediateur,TypesReferentiels.REFERENTIEL_LIEU_DIT) {
 
@Override
public void onModificationValeur() {
lieuDitModifie = true;
}
 
@Override
public void onValidationSaisie() {
validerSaisie(Champs.LIEUDIT);
}
};
panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%"));
milieu = new AutoCompletionRefComboBox("Milieu","milieu",observationMediateur,TypesReferentiels.REFERENTIEL_MILIEU) {
 
@Override
public void onModificationValeur() {
milieuModifie = true;
}
 
@Override
public void onValidationSaisie() {
validerSaisie(Champs.MILIEU);
}
};
panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%"));
 
comment = new TextArea("Notes", "comment");
comment.setAllowBlank(true);
comment.setHeight(50);
 
panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") );
 
Panel panelSeparationPs = new Panel();
panelSeparationPs.setHeight(39);
panelSeparationPs.setBorder(false);
 
panneauSecondeColonne.add(panelSeparationPs);
 
selecteurCertitude = new ComboBox();
selecteurCertitude.setLabel("Identification");
selecteurCertitude.setStore(Ontologies.getValeursCertitude());
selecteurCertitude.setDisplayField("label") ;
selecteurCertitude.setValueField("valeur");
selecteurCertitude.setEditable(true);
selecteurCertitude.setHideTrigger(false);
selecteurCertitude.setForceSelection(false);
selecteurCertitude.setTpl(champsListeTpl);
panneauSecondeColonne.add(selecteurCertitude, new AnchorLayoutData("95%"));
 
selecteurStadePheno = new ComboBox();
selecteurStadePheno.setLabel("Phénologie");
selecteurStadePheno.setStore(Ontologies.getValeursPhenologie());
selecteurStadePheno.setDisplayField("label") ;
selecteurStadePheno.setValueField("valeur");
selecteurStadePheno.setEditable(true);
selecteurStadePheno.setHideTrigger(false);
selecteurStadePheno.setForceSelection(false);
selecteurStadePheno.setTpl(champsListeTpl);
panneauSecondeColonne.add(selecteurStadePheno, new AnchorLayoutData("95%"));
 
if (Window.getClientWidth() > Window.getClientHeight() || Window.getClientWidth() < 800) {
panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5));
panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5));
}
else {
panneauIntermediaire.add(panneauPremierColonne);
panneauIntermediaire.add(panneauSecondeColonne);
}
 
panneauFormulaire.add(panneauIntermediaire);
if (Ext.isIE()) {
panneauPremierColonne.setButtonAlign(Position.RIGHT);
panneauPremierColonne.addButton(boutonOK);
panneauPremierColonne.addButton(boutonModifier);
panneauPremierColonne.addButton(boutonSupprimer);
panneauSecondeColonne.setButtonAlign(Position.LEFT);
panneauPremierColonne.addButton(boutonAnnuler);
}
else {
panneauFormulaire.addButton(boutonOK);
panneauFormulaire.addButton(boutonModifier);
panneauFormulaire.addButton(boutonSupprimer);
panneauFormulaire.addButton(boutonAnnuler);
}
 
this.add(panneauFormulaire) ;
 
this.setAutoScroll(true);
 
 
panneauFormulaire.addListener(new PanelListenerAdapter() {
@Override
public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) {
panneauIntermediaire.setWidth(rawWidth);
panneauIntermediaire.setHeight(rawHeight);
panneauPremierColonne.doLayout();
panneauSecondeColonne.doLayout();
htmlCommunePanel.doLayout();
htmlPanel.doLayout();
doLayout();
}
});
 
lienAfficherChampsEtendus = new HTML("Afficher les champs étendus");
lienAfficherChampsEtendus.setStyleName("img-curseur-depl");
lienAfficherChampsEtendus.setStyleName("lienAfficherChampsEtendus");
lienAfficherChampsEtendus.setVisible(false);
 
lienAfficherChampsEtendus.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
if(afficherChampsEtendus) {
afficherChampsEtendus = false;
if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) {
conteneurChampEtenduGauche.hide();
conteneurChampEtenduDroite.hide();
}
lienAfficherChampsEtendus.setText("Afficher les champs étendus");
 
} else {
afficherChampsEtendus = true;
if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) {
conteneurChampEtenduGauche.show();
conteneurChampEtenduDroite.show();
}
lienAfficherChampsEtendus.setText("Cacher les champs étendus");
}
}
});
if(Configuration.saisieChampsEtendusActivee()) {
// Chargement du cache des correspondances cles/labels du catalogue
ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
lrceDao.obtenirGroupesChampsEtendus(this);
lrceDao.obtenirCatalogueChampsEtendus(this);
lienAjouterChampsEtendus = new HTML("Ajouter un champ étendu");
lienAjouterChampsEtendus.addStyleName("lienAjouterChampEtendu");
lienAjouterChampsEtendus.setVisible(true);
panneauPremierColonne.add(lienAjouterChampsEtendus);
gererLienAjoutChampsEtendus();
}
panneauPremierColonne.add(lienAfficherChampsEtendus);
panneauPremierColonne.addListener(new PanelListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
if(premierAffichage) {
lienAfficherChampsEtendus.setVisible(false);
premierAffichage = false;
}
}
});
 
ajouterListeners() ;
ajouterToolTipsBoutons();
saisieTabindex();
}
private void gererLienAjoutChampsEtendus() {
popUpAjoutChampEtendu.setStylePrimaryName("popup_champ_etendu");
lienAjouterChampsEtendus.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
FormulaireSaisieChampEtendu formChamp = new FormulaireSaisieChampEtendu() {
@Override
public void surValidation(ChampSaisieEtendu champ) {
ajouterChampEtenduAuFormulaire(champ, true);
popUpAjoutChampEtendu.clear();
popUpAjoutChampEtendu.hide();
}
@Override
public void surAjout(ChampSaisieEtendu champ) {
ajouterChampEtenduAuFormulaire(champ, false);
}
 
@Override
public void surAnnulation() {
popUpAjoutChampEtendu.clear();
popUpAjoutChampEtendu.hide();
}
 
@Override
public void surAjoutMultiple(List<ChampSaisieEtendu> champs) {
for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) {
ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next();
ajouterChampEtenduAuFormulaire(champSaisieEtendu, false);
}
}
 
@Override
public void surValidationMultiple(List<ChampSaisieEtendu> champs) {
for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) {
ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next();
ajouterChampEtenduAuFormulaire(champSaisieEtendu, false);
}
popUpAjoutChampEtendu.clear();
popUpAjoutChampEtendu.hide();
}
};
popUpAjoutChampEtendu.add(formChamp);
popUpAjoutChampEtendu.center();
popUpAjoutChampEtendu.setModal(true);
popUpAjoutChampEtendu.show();
}
});
}
private void ajouterChampEtenduAuFormulaire(ChampSaisieEtendu nChamp, boolean fermerPopup) {
ChampEtendu chet = new ChampEtendu(nChamp.getName(), nChamp.getFieldLabel(), "");
Map<String, ChampEtendu> champsEt = getValeursChampsEtendus();
if(!champsEt.containsKey(chet.getCle())) {
champsEt.put(chet.getCle(), chet);
afficherChampsEtendus = true;
if(fermerPopup) {
afficherChampsEtendus(champsEt, chet);
popUpAjoutChampEtendu.clear();
popUpAjoutChampEtendu.hide();
} else {
afficherChampsEtendus(champsEt, null);
}
} else {
Window.alert("Le champ "+chet.getLabel()+" est déjà présent dans le formulaire");
}
}
 
private void ajouterToolTipsBoutons() {
boutonOK.setTitle("Crée une nouvelle observation à partir des champs saisis dans le formulaire");
boutonModifier.setTitle("Modifie la ou les observations sélectionnées");
boutonSupprimer.setTitle("Supprime la ou les observations sélectionnées");
boutonAnnuler.setTitle("Vide tous les champs du formulaire");
}
 
private void surPremierAffichageCoordPanel(final double largeur) {
ExtElement lienCoord = Ext.get("lien_coord");
lienCoord.removeAllListeners();
lienCoord.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
 
coordPanel.setVisible(!coordPanel.isVisible());
 
if(Ext.isIE()) {
latitude.focus();
}
 
CarnetEnLigneMediateur.fireResize();
}
}) ;
 
ExtElement lienCartoCoord = Ext.get("lien_carto_coord");
lienCartoCoord.removeAllListeners();
lienCartoCoord.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
obtenirInformationCoord();
}
}) ;
 
ExtElement lienCarto = Ext.get("lien_carto");
lienCarto.removeAllListeners();
lienCarto.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
 
if(commune.getValue() != null && !commune.getValue().equals("") && !getDepartement().equals("")) {
obtenirInformationCommune();
longlatAjoutee = true;
 
} else {
Window.alert("Veuillez renseigner une commune et un numéro de département sous la forme : Commune (departement)");
}
}
});
 
if(!Ext.isIE() && Window.getClientWidth() < 1200) {
 
int largeurN = (int)largeur;
 
latitude.setWidth(largeurN+"px");
longitude.setWidth(largeurN+"px");
lienSelectionCommune.setWidth(largeurN+"px");
}
}
 
private void ajouterListeners()
{
// Listener completion communne
final Rafraichissable r = this;
ListenerConfig listenerConfigCommune=new ListenerConfig();
listenerConfigCommune.setDelay(200);
listenerConfigCommune.setStopPropagation(false);
listenerConfigCommune.setStopEvent(false);
 
date.addListener(new DatePickerListenerAdapter() {
 
@Override
public void onSelect(DatePicker dataPicker, Date date) {
dateModifiee = true;
}
});
 
ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
listenerConfigAutocompletion.setDelay(200);
listenerConfigAutocompletion.setStopPropagation(false);
listenerConfigAutocompletion.setStopEvent(false);
 
ListenerConfig listenerConfigEspece=new ListenerConfig();
listenerConfigEspece.setDelay(10);
listenerConfigEspece.setStopPropagation(false);
listenerConfigEspece.setStopEvent(false);
 
tCoord = new Timer() {
 
@Override
public void run() {
double[] coord = coordonneesValides();
if(!rechercheCommuneEnCours && coord != null && (longModifiee || latModifiee)) {
rechercheCommuneEnCours = true;
Ext.get(lienSelectionCommune.getElement()).mask("recherche");
observationMediateur.obtenirInformationCoord(r,coord[0], coord[1]);
}
}
 
};
 
ajouterListenerChampEvenementsClavier(commune, listenerConfigCommune);
ajouterListenerChampEvenementsClavier(date);
ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo);
ajouterListenerChampEvenementsClavier(espece, listenerConfigEspece);
ajouterListenerChampEvenementsClavier(comment);
ajouterListenerChampEvenementsClavier(latitude);
ajouterListenerChampEvenementsClavier(longitude);
ajouterListenerChampEvenementsClavier(altitude);
ajouterListenerChampEvenementsClavier(selecteurAbondance);
ajouterListenerChampEvenementsClavier(selecteurCertitude);
ajouterListenerChampEvenementsClavier(selecteurStadePheno);
ajouterListenerChampsCombobox();
 
boutonOK.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
ajouterObservation();
}
});
 
boutonModifier.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(selectionMultiple) {
modifierObservationEnMasse(null);
} else {
modifierObservation() ;
}
}
});
 
boutonSupprimer.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(!selectionMultiple) {
supprimerObservation();
} else {
observationMediateur.supprimerObservations();
}
}
});
 
boutonAnnuler.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
setSelectionMultiple(false);
raz();
}
});
 
this.addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container self) {
commune.focus();
}
});
}
 
private void ajouterListenerChampsCombobox() {
commune.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
commune.setValue(record.getAsString("commune"));
departement=record.getAsString("departement");
codeInseeCommune=record.getAsString("codeInsee");
selectionCommune=true;
commune.collapse();
}
 
@Override
public void onExpand(ComboBox comboBox) {
comboBox.focus();
}
});
 
selecteurReferentielTaxo.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
referentielTaxo = record.getAsString("valeur");
observationMediateur.setRefTaxSelectionne(index);
referentielTaxoModifie = true;
}
});
 
espece.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
espece.setValue(record.getAsString("nom"));
numeroNom=record.getAsString("numeroNom");
selectionEspece=true;
observationMediateur.obtenirImageInformationExternes(referentielTaxo, numeroNom);
}
});
 
selecteurAbondance.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
selectionAbondance=true;
abondanceModifiee = true;
}
});
 
selecteurCertitude.addListener(new ComboBoxListenerAdapter() {
 
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
selectionCertitude=true;
certitudeModifiee = true;
}
});
 
selecteurStadePheno.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
selectionPhenologie=true;
phenologieModifiee = true;
}
});
}
 
private void ajouterListenerChampEvenementsClavier(final TextField champ) {
champ.addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
surEvenementClavier(e, champ);
}
});
}
 
private void ajouterListenerChampEvenementsClavier(final TextField champ, final ListenerConfig config) {
champ.addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
surEvenementClavier(e, champ);
}
}, config);
}
 
private void surEvenementClavier(EventObject e, TextField champ) {
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
 
case KEY_ENTER:
surEvenementClavierToucheEntree(champ);
break;
 
default:
gererEvenementClavierDefaut(champ);
break;
}
}
 
private void surEvenementClavierToucheEntree(TextField champ) {
//TODO: faire un switch ou une enum
if(champ.equals(selecteurStadePheno)) {
if(!selectionPhenologie) {
validerSaisie(Champs.PHENOLOGIE);
} else {
selectionPhenologie = false;
}
}
 
if(champ.equals(selecteurCertitude)) {
if(!selectionCertitude) {
validerSaisie(Champs.CERTITUDE);
} else {
selectionCertitude = false;
}
}
 
if(champ.equals(selecteurAbondance)) {
if(!selectionAbondance) {
validerSaisie(Champs.ABONDANCE);
} else {
selectionAbondance = false;
}
}
 
if(champ.equals(longitude)) {
validerSaisie(Champs.LONGITUDE);
}
 
if(champ.equals(latitude)) {
validerSaisie(Champs.LATITUDE);
}
 
if(champ.equals(altitude)) {
validerSaisie(Champs.ALTITUDE);
}
 
if(champ.equals(espece)) {
if(selectionEspece) {
especeModifiee = true;
selectionEspece=false;
}
else {
validerSaisie(Champs.ESPECE);
}
}
 
if(champ.equals(selecteurReferentielTaxo)) {
validerSaisie(Champs.REFERENTIELTAXO);
}
 
if(champ.equals(date)) {
validerSaisie(Champs.DATE);
}
 
if(champ.equals(commune)) {
if(champ.equals(commune)) {
if (selectionCommune) {
communeModifiee= true;
selectionCommune=false;
}
else {
validerSaisie(Champs.COMMUNE);
}
}
}
}
 
private void gererEvenementClavierDefaut(TextField champ) {
//TODO: faire un switch ou une enum
if(champ.equals(selecteurStadePheno)) {
selecteurStadePheno.setRawValue(selecteurStadePheno.getRawValue());
selecteurStadePheno.setValue(selecteurStadePheno.getRawValue());
phenologieModifiee = true;
selectionPhenologie = false;
}
 
if(champ.equals(selecteurCertitude)) {
selecteurCertitude.setRawValue(selecteurCertitude.getRawValue());
selecteurCertitude.setValue(selecteurCertitude.getRawValue());
certitudeModifiee = true;
selectionCertitude = false;
}
 
if(champ.equals(selecteurAbondance)) {
selecteurAbondance.setRawValue(selecteurAbondance.getRawValue());
selecteurAbondance.setValue(selecteurAbondance.getRawValue());
abondanceModifiee = true;
selectionAbondance = false;
}
 
if(champ.equals(longitude)) {
longModifiee = true;
tCoord.cancel();
tCoord.schedule(250);
}
 
if(champ.equals(latitude)) {
latModifiee = true;
tCoord.cancel();
tCoord.schedule(250);
}
 
if(champ.equals(altitude)) {
altModifiee = true;
}
 
if(champ.equals(comment)) {
commModifie = true;
}
 
if(champ.equals(espece)) {
numeroNom="";
obtenirListeReferentielNom();
especeModifiee = true;
}
 
if(champ.equals(selecteurReferentielTaxo)) {
referentielTaxoModifie = true;
}
 
if(champ.equals(date)) {
dateModifiee = true;
}
 
if(champ.equals(commune)) {
departement="";
commune.collapse();
obtenirListeReferentielCommune();
communeModifiee= true;
}
}
 
/**
* Validation de la saisie
*/
 
private void validerSaisie(Champs champs) {
if(!selectionMultiple) {
ajouterObservation();
raz(champs);
} else {
modifierObservationEnMasse(champs);
}
}
 
/**
* Desactive visuellement ce panneau
*/
public void desactiverPanneau()
{
this.setDisabled(true) ;
}
 
/**
* Active visuellement ce panneau
*/
public void activerPanneau()
{
this.setDisabled(false) ;
}
 
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
 
// si l'on a reçu une liste du referentiel commune (completion referentiel commune)
if(nouvelleDonnees instanceof ListeReferentielCommune)
{
ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ;
Object[][] communeData = new Object[data.size()][3];
int i = 0 ;
 
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
ReferentielCommune ref=data.get(it.next());
 
communeData[i][0]= ref.getCommune();
communeData[i][1]= ref.getDepartement();
communeData[i][2]= ref.getCodeInsee();
i++ ;
}
 
// creation du store
FieldDef defCommune = new StringFieldDef("commune");
FieldDef defDepartement = new StringFieldDef("departement");
FieldDef defCodeInsee = new StringFieldDef("codeInsee");
 
FieldDef[] defTab = { defCommune, defDepartement, defCodeInsee};
 
RecordDef rd = new RecordDef(defTab);
 
final MemoryProxy dataProxy = new MemoryProxy(communeData);
final ArrayReader reader = new ArrayReader(rd);
 
Store store=new Store(dataProxy,reader);
commune.setStore(store);
store.load();
 
}
 
// si l'on a reçu une liste du référentiel nom (complétion referentiel nom)
if(nouvelleDonnees instanceof ListeReferentielNom)
{
ListeReferentielNom data = (ListeReferentielNom) nouvelleDonnees ;
Object[][] nomData = new Object[data.size()][3];
int i = 0 ;
 
// on la parse et on récupère les informations qui nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
 
ReferentielNom ref=data.get(it.next());
 
nomData[i][0]= ref.getNom();
nomData[i][1]= ref.getNumeroNom();
if (ref.getStatut().equals("3")) {
nomData[i][2]="nom_retenu";
}
else {
nomData[i][2]="";
}
i++ ;
}
 
FieldDef defNom = new StringFieldDef("nom");
FieldDef defNumeroNom = new StringFieldDef("numeroNom");
FieldDef indicateurNomRetenu = new StringFieldDef("indicateurNomRetenu");
 
FieldDef[] defTab = { defNom, defNumeroNom, indicateurNomRetenu};
 
RecordDef rd = new RecordDef(defTab);
 
final MemoryProxy dataProxy = new MemoryProxy(nomData);
final ArrayReader reader = new ArrayReader(rd);
 
Store store=new Store(dataProxy,reader);
espece.setStore(store);
store.load() ;
}
 
// On recoit une observation dont on veut afficher le detail
 
if(nouvelleDonnees instanceof Observation)
{
Observation obs = (Observation)nouvelleDonnees ;
setSelectionMultiple(false);
afficherDetailsObservation(obs) ;
}
 
if(nouvelleDonnees instanceof ListeObservation) {
 
ListeObservation listeObs = (ListeObservation)nouvelleDonnees;
setSelectionMultiple(true);
calculerAfficherDifferences(listeObs);
}
 
if(nouvelleDonnees instanceof String)
{
String str = (String)nouvelleDonnees ;
observationMediateur.obtenirNombreObservation() ;
}
 
if(nouvelleDonnees instanceof String[]) {
String[] anumNom = (String[])nouvelleDonnees ;
numeroNom = anumNom[1];
espece.setValue(anumNom[0]);
}
 
if(nouvelleDonnees instanceof EntiteGeographiqueObservation)
{
EntiteGeographiqueObservation infosComm = (EntiteGeographiqueObservation)nouvelleDonnees ;
if(rechercheCommuneEnCours) {
afficherIndicationCommune(infosComm);
} else {
rafraichirCommuneEtCoord(infosComm);
}
}
}
 
private void afficherIndicationCommune(
final EntiteGeographiqueObservation infosCom) {
 
String nCommune = "";
if(infosCom != null && !infosCom.getZoneGeo().trim().equals("")){
nCommune += infosCom.getZoneGeo();
if(!infosCom.getIdZoneGeo().trim().equals(""))
nCommune += " ("+Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo())+")";
 
lienSelectionCommune.setHtml("<a id=\"lien_selection_commune\" tabindex=\"9\">"+nCommune+"</a>");
lienSelectionCommune.setStyleName("img-curseur-depl");
 
Ext.get("lien_selection_commune").addListener("click",new EventCallback() {
@Override
public void execute(EventObject e) {
rafraichirCommune(infosCom);
}
});
 
Ext.get("lien_selection_commune").addListener("keypress",new EventCallback() {
@Override
public void execute(EventObject e) {
if(e.getCharCode() == KEY_ENTER) {
rafraichirCommune(infosCom);
}
}
});
 
Ext.get("lien_selection_commune").addListener("focus",new EventCallback() {
@Override
public void execute(EventObject e) {
Ext.get("lien_selection_commune").toggleClass("lien_sel");
}
});
 
Ext.get("lien_selection_commune").addListener("blur",new EventCallback() {
@Override
public void execute(EventObject e) {
Ext.get("lien_selection_commune").toggleClass("lien_sel");
}
});
 
} else {
if(rechercheCommuneEnCours) {
lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> Erreur de localisation </span>");
} else {
lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> </span>");
}
}
 
Ext.get(lienSelectionCommune.getElement()).unmask();
rechercheCommuneEnCours = false;
}
 
private void rafraichirCommune(EntiteGeographiqueObservation infosCom) {
String nCommune = "";
 
if(infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().equals("")) {
nCommune += infosCom.getZoneGeo();
}
 
if(infosCom.getIdZoneGeo() != null && !infosCom.getIdZoneGeo().equals("")) {
String codeGeoFormate = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo());
nCommune += " ("+codeGeoFormate+")";
departement = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo());
}
if (! nCommune.equals("")) {
commune.setValue(nCommune);
communeModifiee = true;
}
}
 
// Se déclenche au retour de la "localisation sur la carte"
private void rafraichirCommuneEtCoord(EntiteGeographiqueObservation infosCom) {
 
rafraichirCommune(infosCom);
if(infosCom.getLat() != null && !infosCom.getLat().equals("")) {
latitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLat(), 5));
}
 
if(infosCom.getLon() != null && !infosCom.getLon().equals("")) {
longitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLon(), 5));
}
 
latModifiee = true;
longModifiee = true;
 
coordPanel.setVisible(true);
}
 
public void obtenirListeReferentielCommune() {
 
String com=commune.getText();
com=com.replaceAll("%","");
 
observationMediateur.obtenirListeReferentielCommune(this,com);
 
}
 
public void obtenirListeReferentielNom() {
String esp=espece.getText().replaceAll(" ","/*");
esp=esp.replaceAll("%","");
String referentiel = this.referentielTaxo;
observationMediateur.obtenirListeReferentielNom(this,referentiel ,esp);
}
 
protected void obtenirReferentielStation() {
observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_STATION,station.getText());
}
 
protected void obtenirListeReferentielMilieu() {
observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_MILIEU,milieu.getText());
}
 
protected void obtenirReferentielLieuDit() {
observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_LIEU_DIT,lieudit.getText());
}
 
public void ajouterObservation() {
 
if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) {
Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa");
date.setInvalidText("Date invalide");
return;
}
 
if(departement != null) {
if(departement.equals("000null") || departement.equals("")) {
String[] depCom = commune.getText().split(" ");
if(depCom.length > 1) {
String dep = depCom[1].replace('(', ' ');
dep =dep.replace(')', ' ');
dep = dep.trim();
dep = dep.replace('\\',' ');
dep = dep.trim();
 
try
{
int nDep = Integer.parseInt(dep);
if(nDep > 0 && nDep < 110) {
departement = dep ;
}
}
catch(NumberFormatException e)
{
departement = "" ;
}
}
}
}
 
String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue());
 
Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs);
 
String[] coords = getValeurCoordonnees();
obs.setLatitude(coords[0]);
obs.setLongitude(coords[1]);
obs.setAltitude(altitude.getText());
 
obs.setAbondance(getAbondance());
obs.setCertitude(getCertitude());
obs.setPhenologie(getPhenologie());
 
obs.setReferentielTaxo(Ontologies.getInfosReferentielNomParCode(referentielTaxo).getCodeVersionComplet());
obs.setChampsEtendus(getValeursChampsEtendus());
 
observationMediateur.ajouterObservation(obs);
}
 
private void modifierObservation() {
 
if(!Window.confirm("Êtes-vous sur de vouloir modifier l'observation sélectionnée ?")) {
return;
}
 
if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) {
Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa");
date.setInvalidText("Date invalide");
return;
}
 
if(departement.equals("000null") || departement.equals("")) {
String[] depCom = commune.getText().split(" ");
if(depCom.length > 1) {
String dep = depCom[1].replace('(', ' ');
dep =dep.replace(')', ' ');
dep = dep.trim();
dep = dep.replace('\\',' ');
dep = dep.trim();
 
try
{
int nDep = Integer.parseInt(dep);
if(nDep > 0 && nDep < 110) {
departement = dep ;
}
}
catch(NumberFormatException e)
{
departement = "" ;
}
}
}
 
String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue());
 
Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs);
obs.setNumeroOrdre(numeroOrdre);
 
String[] coords = getValeurCoordonnees();
 
obs.setLatitude(coords[0]);
obs.setLongitude(coords[1]);
obs.setAltitude(altitude.getText());
 
obs.setAbondance(getAbondance());
obs.setCertitude(getCertitude());
obs.setPhenologie(getPhenologie());
obs.setReferentielTaxo(getReferentielTaxo());
obs.setChampsEtendus(getValeursChampsEtendus());
 
observationMediateur.modifierObservation(obs);
}
 
private void modifierObservationEnMasse(Champs champModifie) {
 
//TODO: factoriser
String communeM = null;
String departementM = null;
String numNomSelM = null;
String lieuDitM = null;
String stationM = null;
String milieuM = null;
String dateM = null;
String especeM = null;
String commM = null;
String latM = null;
String longM = null;
String altM = null;
String abondanceM = null;
String certitudeM = null;
String referentielTaxoM = null;
String phenologieM = null;
 
String champs = modeleMessageModif;
 
if(communeModifiee && ! commune.getRawValue().equals(VALEURS_MULTIPLES)) {
communeM = commune.getText();
 
if(departement.equals("000null") || departement.equals("")) {
String[] depCom = commune.getText().split(" ");
if(depCom.length > 1) {
String dep = depCom[1].replace('(', ' ');
dep =dep.replace(')', ' ');
dep = dep.trim();
dep = dep.replace('\\',' ');
dep = dep.trim();
 
try {
int nDep = Integer.parseInt(dep);
if(nDep > 0 && nDep < 110) {
departement = dep ;
}
}
catch(NumberFormatException e) {
departement = "" ;
}
}
}
departementM = departement;
}
else {
champs = champs.replaceAll("commune", "");
}
 
if(lieuDitModifie && ! lieudit.getRawValue().equals(VALEURS_MULTIPLES)) {
lieuDitM = lieudit.getText();
} else {
champs = champs.replaceAll(":lieu-dit", "");
}
 
if(stationModifiee && ! station.getRawValue().equals(VALEURS_MULTIPLES)) {
stationM = station.getText();
} else {
champs = champs.replaceAll(":station", "");
}
 
if(milieuModifie && ! milieu.getRawValue().equals(VALEURS_MULTIPLES)) {
milieuM = milieu.getText();
} else {
champs = champs.replaceAll(":milieu", "");
}
 
if(dateModifiee && ! date.getRawValue().equals(VALEURS_MULTIPLES)) {
dateM = date.getRawValue();
dateM = Util.remplacerSeparateursDateFormatCel(dateM);
} else {
champs = champs.replaceAll(":date", "");
}
 
if(especeModifiee && ! espece.getRawValue().equals(VALEURS_MULTIPLES)) {
especeM = espece.getText();
numNomSelM = numeroNom;
} else {
champs = champs.replaceAll(":espece", "");
}
 
if(commModifie && ! comment.getRawValue().equals(VALEURS_MULTIPLES)) {
commM = comment.getText();
} else {
champs = champs.replaceAll(":commentaire", "");
}
 
if(latModifiee && ! latitude.getRawValue().equals(VALEURS_MULTIPLES)) {
latM = latitude.getText();
} else {
champs = champs.replaceAll(":latitude", "");
}
 
if(altModifiee && ! altitude.getRawValue().equals(VALEURS_MULTIPLES)) {
altM = altitude.getText();
} else {
champs = champs.replaceAll(":altitude", "");
}
 
if(longModifiee && ! longitude.getRawValue().equals(VALEURS_MULTIPLES)) {
longM = longitude.getText();
} else {
champs = champs.replaceAll(":longitude", "");
}
 
if(abondanceModifiee && !selecteurAbondance.getRawValue().equals(VALEURS_MULTIPLES)) {
abondanceM = getAbondance();
} else {
champs = champs.replaceAll(":abondance", "");
}
 
if(certitudeModifiee && !selecteurCertitude.getRawValue().equals(VALEURS_MULTIPLES)) {
certitudeM = getCertitude();
} else {
champs = champs.replaceAll(":identification", "");
}
 
if(referentielTaxoModifie && !selecteurReferentielTaxo.getRawValue().equals(VALEURS_MULTIPLES)) {
referentielTaxoM = getReferentielTaxo();
} else {
champs = champs.replaceAll(":referentiel", "");
}
 
if(phenologieModifiee && !selecteurStadePheno.getRawValue().equals(VALEURS_MULTIPLES)) {
phenologieM = getPhenologie();
} else {
champs = champs.replaceAll(":phenologie", "");
}
 
champs = champs.replaceAll(":",", ");
if(champs.startsWith(",")) {
champs = champs.replaceFirst(",", "");
}
 
String message = "Voulez vous modifier le(s) champ(s) suivant(s) : "+champs+" pour les observations selectionnées ?" ;
 
if(champs.trim().equals("")) {
Window.alert("Aucun champ n'a été modifié");
} else {
Observation obs = new Observation(especeM,numNomSelM,communeM,departementM,lieuDitM,stationM,milieuM, commM,dateM);
obs.setNumeroOrdre(numeroOrdre);
obs.setLatitude(latM);
obs.setLongitude(longM);
obs.setAltitude(altM);
obs.setAbondance(abondanceM);
obs.setCertitude(certitudeM);
obs.setReferentielTaxo(referentielTaxoM);
obs.setPhenologie(phenologieM);
if(Window.confirm(message)) {
observationMediateur.modifierObservationEnMasse(obs);
reinitialiserValeurModifiees();
}
}
}
 
private void supprimerObservation() {
observationMediateur.supprimerObservation(this, numeroOrdre);
}
 
public void afficherDetailsObservation(Observation obs)
{
raz() ;
String idLoc ;
if(obs.getIdentifiantLocalite() != VALEURS_MULTIPLES) {
idLoc = obs.getIdentifiantLocalite().replaceAll(" ","/");
idLoc = idLoc.replaceAll("%","");
idLoc = idLoc.replaceAll("\"","");
idLoc = idLoc.replace('\\',' ');
idLoc = idLoc.trim();
if(idLoc.length() == 5) {
idLoc = idLoc.substring(0,2);
}
} else {
idLoc = obs.getIdentifiantLocalite();
if(idLoc.length() == 5) {
idLoc = idLoc.substring(0,2);
}
}
 
if(!obs.getDate().equals("null") && !obs.getDate().equals("000null") && !obs.getDate().equals(VALEURS_MULTIPLES)) {
String[] dateEtHeure = obs.getDate().split(" ", 2);
if(verifierFormatDate(dateEtHeure[0])) {
date.setValue(dateEtHeure[0]) ;
}
else
{
date.setRawValue("");
}
} else {
date.setRawValue(VALEURS_MULTIPLES);
date.clearInvalid();
}
if(!obs.getLieudit().equals("null") && !obs.getLieudit().equals("000null")) {
lieudit.setValue(obs.getLieudit()) ;
}
if(!obs.getStation().equals("null") && !obs.getStation().equals("000null")) {
station.setValue(obs.getStation()) ;
}
if(!obs.getMilieu().equals("null") && !obs.getMilieu().equals("000null")) {
milieu.setValue(obs.getMilieu()) ;
}
if(!obs.getCommentaire().equals("null") && !obs.getCommentaire().equals("000null")) {
 
comment.setRawValue(Util.remplacerSautsDeligneMalEncodes(obs.getCommentaire()));
 
}
if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) {
if(!idLoc.equals("000null") && !idLoc.equals("")) {
if(!idLoc.equals(VALEURS_MULTIPLES)) {
commune.setValue(obs.getLocalite()+" ("+idLoc+")") ;
} else {
commune.setValue(VALEURS_MULTIPLES);
}
}
else
{
commune.setValue(obs.getLocalite());
}
}
if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) {
departement = idLoc;
}
if(!obs.getNomSaisi().equals("null") && !obs.getNomSaisi().equals("000null")) {
espece.setValue(obs.getNomSaisi()) ;
}
if(!obs.getNumeroNomenclaturalSaisi().equals("null") && !obs.getNumeroNomenclaturalSaisi().equals("000null")) {
numeroNom = obs.getNumeroNomenclaturalSaisi() ;
}
if(!obs.getNumeroOrdre().equals("null") && !obs.getNumeroOrdre().equals("000null")) {
numeroOrdre = obs.getNumeroOrdre() ;
}
 
if(doitAfficherLatLon(obs)) {
latitude.setValue(Util.formaterNombre(obs.getLatitude())) ;
longitude.setValue(Util.formaterNombre(obs.getLongitude())) ;
}
 
if(!obs.getAltitude().isEmpty() && !obs.getAltitude().equals("null") && !obs.getAltitude().equals("000null")) {
altitude.setValue(Util.formaterNombre(obs.getAltitude())) ;
}
 
selecteurAbondance.getStore().load();
selecteurAbondance.setValue(obs.getAbondance());
 
selecteurCertitude.getStore().load();
selecteurCertitude.setValue(obs.getCertitude());
 
selecteurStadePheno.getStore().load();
selecteurStadePheno.setValue(obs.getPhenologie());
 
selecteurReferentielTaxo.getStore().load();
if(obs.getReferentielTaxo() != VALEURS_MULTIPLES) {
referentielTaxo = obs.getCodeCourtReferentielTaxo();
if(referentielTaxo == null || referentielTaxo.isEmpty()) {
referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode();
}
selecteurReferentielTaxo.setValue(referentielTaxo);
} else {
referentielTaxo = "";
selecteurReferentielTaxo.setRawValue(VALEURS_MULTIPLES);
}
 
afficherChampsEtendus(obs.getChampsEtendus(), null);
}
 
private boolean doitAfficherLatLon(Observation obs) {
return !obs.getLatitude().isEmpty() &&
!obs.getLatitude().equals("null") &&
!obs.getLatitude().equals("000null") &&
!Util.estZero(obs.getLatitude()) &&
!obs.getLongitude().isEmpty() &&
!obs.getLongitude().equals("null") &&
!obs.getLongitude().equals("000null") &&
!Util.estZero(obs.getLongitude());
}
 
private void viderChampsEtendus() {
if(listeChampsEtendus != null) {
for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) {
TextField champEtendu = listeChampsEtendus.get(it.next());
champEtendu.destroy();
}
if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) {
conteneurChampEtenduGauche.clear();
conteneurChampEtenduDroite.clear();
panneauPremierColonne.remove(conteneurChampEtenduGauche);
panneauSecondeColonne.remove(conteneurChampEtenduDroite);
}
listeChampsEtendus = null;
}
}
 
private void afficherChampsEtendus(Map<String, ChampEtendu> champsEtendus, ChampEtendu champsAFocus) {
champsEtendus = Util.trierListeChampsEtendus(champsEtendus);
viderChampsEtendus();
 
FormLayout flmd = new FormLayout();
flmd.setLabelWidth(150);
 
FormLayout flmg = new FormLayout();
flmg.setLabelWidth(150);
 
conteneurChampEtenduGauche = new Panel();
conteneurChampEtenduGauche.setLayout(flmg);
conteneurChampEtenduDroite = new Panel();
conteneurChampEtenduDroite.setLayout(flmd);
 
conteneurChampEtenduGauche.setAutoWidth(true);
conteneurChampEtenduGauche.setStyle("conteneurChampsEtendus");
conteneurChampEtenduGauche.setBodyBorder(false);
conteneurChampEtenduDroite.setAutoWidth(true);
conteneurChampEtenduDroite.setStyle("conteneurChampsEtendus");
conteneurChampEtenduDroite.setBodyBorder(false);
 
// pour corriger le décalage sur le panneau induit par le lien d'affichage
conteneurChampEtenduDroite.setPaddings(42, 0, 0, 0);
 
if(champsEtendus != null && champsEtendus.size() > 0) {
lienAfficherChampsEtendus.setVisible(true);
listeChampsEtendus = new HashMap<String, ChampSaisieEtendu>(champsEtendus.size());
HashMap<String, String> correspondancesClesLabel = ListeReferentielChampsEtendusDAO.cacheClesLabels;
boolean gauche = true;
for (Iterator<String> iterator = champsEtendus.keySet().iterator(); iterator.hasNext();) {
String id = iterator.next();
ChampEtendu champ = champsEtendus.get(id);
String valeur = champ.getValeur();
String label = id;
// Si le champ possède un clé déjà définie par le catalogue, elle lui sera affectée
// sinon on la formate en la "déchamotant" et en ajoutant des espaces
if(correspondancesClesLabel.containsKey(id)) {
label = correspondancesClesLabel.get(id);
} else {
label = Util.formaterCleChampsEtenduPourAffichage(label);
}
 
ChampSaisieEtendu champTexteEtendu = new ChampSaisieEtendu(label, id);
if(champ.equals(champsAFocus)) {
champTexteEtendu.focus();
}
champTexteEtendu.setId(id);
champTexteEtendu.setValue(valeur);
if(gauche) {
conteneurChampEtenduGauche.add(champTexteEtendu);
} else {
conteneurChampEtenduDroite.add(champTexteEtendu);
}
listeChampsEtendus.put(id, champTexteEtendu);
gauche = !gauche;
}
 
panneauPremierColonne.add(conteneurChampEtenduGauche);
panneauSecondeColonne.add(conteneurChampEtenduDroite);
 
if(!afficherChampsEtendus) {
conteneurChampEtenduGauche.setVisible(false);
conteneurChampEtenduDroite.setVisible(false);
}
} else {
lienAfficherChampsEtendus.setVisible(false);
}
doLayout();
}
 
private Map<String, ChampEtendu> getValeursChampsEtendus() {
Map<String, ChampEtendu> valeursChampsEtendus = new HashMap<String, ChampEtendu>();
if(listeChampsEtendus != null) {
for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) {
String cle = it.next();
TextField champTexteEtendu = listeChampsEtendus.get(cle);
String label = champTexteEtendu.getFieldLabel();
String valeur = champTexteEtendu.getValueAsString();
ChampEtendu champEtendu = new ChampEtendu(cle, label, valeur);
valeursChampsEtendus.put(cle, champEtendu);
}
}
return valeursChampsEtendus;
}
 
public void raz()
{
raz(Champs.TOUT);
 
}
public void raz(Champs champs)
{
switch (champs) {
case DATE:
date.reset() ;
break;
 
case LIEUDIT:
lieudit.reset() ;
break;
 
case STATION:
station.reset() ;
break;
 
case MILIEU:
milieu.reset() ;
break;
 
case COMMENT:
comment.reset() ;
break;
 
case COMMUNE:
commune.reset() ;
departement ="";
latitude.reset();
longitude.reset();
break;
 
case ESPECE:
espece.reset();
numeroNom = "" ;
numeroOrdre = "";
break;
 
case LATITUDE:
latitude.reset();
afficherIndicationCommune(null);
break;
 
case LONGITUDE:
longitude.reset();
afficherIndicationCommune(null);
break;
 
case ALTITUDE:
altitude.reset();
break;
 
case ABONDANCE:
selecteurAbondance.setValue("");
break;
 
case CERTITUDE:
selecteurCertitude.setValue("");
break;
 
case REFERENTIELTAXO:
selecteurReferentielTaxo.setValue("");
break;
 
case PHENOLOGIE:
selecteurStadePheno.setValue("");
break;
 
case TOUT:
commune.reset();
date.reset() ;
lieudit.reset() ;
station.reset() ;
milieu.reset() ;
comment.reset() ;
milieu.reset() ;
latitude.reset();
longitude.reset();
altitude.reset();
departement ="";
espece.reset();
selecteurAbondance.clearValue();
selecteurCertitude.clearValue();
selecteurReferentielTaxo.clearValue();
selecteurStadePheno.clearValue();
referentielTaxo = "";
numeroNom = "" ;
numeroOrdre = "";
afficherIndicationCommune(null);
break;
 
}
 
}
 
public boolean verifierFormatDate(String date) {
 
String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
if(date.matches(regex) && !date.equals("0000-00-00")) {
return true ;
}
else {
return false;
}
}
 
public void setSelectionMultiple(boolean selectionMultiple) {
this.selectionMultiple = selectionMultiple;
if(!selectionMultiple) {
boutonAnnuler.enable();
boutonOK.enable();
} else {
boutonAnnuler.disable();
boutonOK.disable();
}
}
 
public boolean getSelectionMultiple() {
return selectionMultiple;
}
 
private void calculerAfficherDifferences(ListeObservation listeObs) {
 
String departement = null;
String commune = null;
String lieuDit = null;
String station = null;
String milieu = null;
String espece = null;
String date = null;
String notes = null;
String lat = null;
String lon = null;
String alt = null;
String abondance = null;
String certitude = null;
String referentielTaxo = null;
String phenologie = null;
 
String ordreObs = "";
 
for(Iterator<String> it = listeObs.keySet().iterator();it.hasNext();) {
Observation obsEnCours = listeObs.get(it.next());
departement = comparerDifferencesChamps(departement, obsEnCours.getIdentifiantLocalite());
commune = comparerDifferencesChamps(commune, obsEnCours.getLocalite());
lieuDit = comparerDifferencesChamps(lieuDit, obsEnCours.getLieudit());
station = comparerDifferencesChamps(station, obsEnCours.getStation());
milieu = comparerDifferencesChamps(milieu, obsEnCours.getMilieu());
espece = comparerDifferencesChamps(espece, obsEnCours.getNomSaisi());
date = comparerDifferencesChamps(date, obsEnCours.getDate());
notes = comparerDifferencesChamps(notes, obsEnCours.getCommentaire());
lat = comparerDifferencesChamps(lat, obsEnCours.getLatitude());
lon = comparerDifferencesChamps(lon, obsEnCours.getLongitude());
alt = comparerDifferencesChamps(alt, obsEnCours.getAltitude());
abondance = comparerDifferencesChamps(abondance, obsEnCours.getAbondance());
certitude = comparerDifferencesChamps(certitude, obsEnCours.getCertitude());
referentielTaxo = comparerDifferencesChamps(referentielTaxo, obsEnCours.getReferentielTaxo());
phenologie = comparerDifferencesChamps(phenologie, obsEnCours.getPhenologie());
 
ordreObs += obsEnCours.getNumeroOrdre()+",";
}
 
Observation obs=new Observation(espece,numeroNom,commune,departement,lieuDit,station,milieu, notes,date);
obs.setNumeroOrdre(ordreObs);
obs.setLatitude(lat);
obs.setLongitude(lon);
obs.setAltitude(alt);
obs.setAbondance(abondance);
obs.setCertitude(certitude);
obs.setReferentielTaxo(referentielTaxo);
obs.setPhenologie(phenologie);
afficherDetailsObservation(obs);
}
 
private String comparerDifferencesChamps(String valeurActuelle, String nouvelleValeur) {
 
String retour = "000null";
 
if(valeurActuelle == null) {
retour = nouvelleValeur;
} else {
if(valeurActuelle.equals(nouvelleValeur)) {
retour = valeurActuelle;
} else {
retour = VALEURS_MULTIPLES;
}
}
return retour;
}
 
private void reinitialiserValeurModifiees() {
communeModifiee = false;
lieuDitModifie = false;
stationModifiee = false;
milieuModifie = false;
dateModifiee = false;
especeModifiee = false;
commModifie = false;
latModifiee = false;
longModifiee = false;
altModifiee = false;
abondanceModifiee = false;
certitudeModifiee = false;
referentielTaxoModifie = false;
phenologieModifiee = false;
}
 
public void saisieTabindex()
{
commune.setTabIndex(1);
lieudit.setTabIndex(3);
station.setTabIndex(4);
milieu.setTabIndex(5);
coordonnees.setTabIndex(-1);
coordonnees.addListener(new TextFieldListenerAdapter() {
 
@Override
public void onFocus(Field field) {
if(coordPanel.isVisible()) {
latitude.focus();
} else {
Ext.get("lien_carto").focus();
}
}
});
 
latitude.setTabIndex(8);
longitude.setTabIndex(9);
altitude.setTabIndex(10);
comment.setTabIndex(11);
date.setTabIndex(12);
espece.setTabIndex(13);
selecteurCertitude.setTabIndex(14);
selecteurAbondance.setTabIndex(15);
selecteurStadePheno.setTabIndex(16);
boutonOK.setTabIndex(17);
boutonAnnuler.setTabIndex(18);
 
}
 
private void obtenirInformationCoord() {
if(coordonneesValides() != null) {
observationMediateur.obtenirInformationCoord(coordonneesValides()[0],coordonneesValides()[1]);
} else {
observationMediateur.afficherFenetreCarto();
}
}
 
private void obtenirInformationCommune() {
observationMediateur.obtenirInformationCommune(getCommuneSansDepartement(), Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText()));
}
 
public double[] coordonneesValides() {
 
try {
 
double lat = Double.parseDouble(latitude.getValueAsString().replaceAll(",", "."));
double lon = Double.parseDouble(longitude.getValueAsString().replaceAll(",", "."));
 
double[] coord = {lat, lon};
return coord;
 
} catch (NumberFormatException ne) {
return null;
}
}
 
private String[] getValeurCoordonnees() {
double[] coDouble = coordonneesValides();
 
if(coDouble != null) {
String[] coord = {coDouble[0]+"",coDouble[1]+""};
return coord;
} else {
String[] coord = {"000null","000null" };
return coord;
}
}
 
public String getCommune() {
 
String valeurCommune = "";
 
if(commune.getValue() != null) {
valeurCommune = commune.getValue();
}
return valeurCommune;
}
 
public String getDepartement() {
return Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText());
}
 
public String getCommuneSansDepartement() {
return Util.supprimerNumDepartementChaineLocalite(getCommune());
}
 
private String getValeurChampListeLibre(ComboBox champ) {
String valeurChamp = champ.getValue();
String valeurChampBrute = champ.getRawValue();
 
// Test idiot qui permet de savoir si l'on utilise la valeur saisie directement ou bien la valeur
// selectionnee car lors du setValue sur le keypress, gwtext ne prends pas en compte le dernier
// caractère
if(valeurChampBrute.trim().length() == 0) {
valeurChamp = "";
} else {
if(valeurChamp != null && valeurChamp.length() > 0) {
if(valeurChamp.equals(valeurChampBrute.substring(0, valeurChampBrute.length() -1))) {
valeurChamp = champ.getRawValue();
}
}
}
return valeurChamp;
}
 
public String getAbondance() {
return getValeurChampListeLibre(selecteurAbondance);
}
 
public String getCertitude() {
return getValeurChampListeLibre(selecteurCertitude);
}
 
public String getPhenologie() {
return getValeurChampListeLibre(selecteurStadePheno);
}
 
public String getReferentielTaxo() {
String codeCourt = getValeurChampListeLibre(selecteurReferentielTaxo);
return Ontologies.getInfosReferentielNomParCode(codeCourt).getCodeVersionComplet();
}
 
public boolean communeInitialisee() {
return communeModifiee;
}
 
public void redimensionnerFormulaire() {
afficherFormulaireLatLon.setWidth(panneauIntermediaire.getWidth()+"px");
panneauPremierColonne.doLayout();
panneauSecondeColonne.doLayout();
panneauIntermediaire.doLayout();
 
doLayout();
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java
New file
0,0 → 1,179
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue;
import org.tela_botanica.client.vues.observation.filtres.ArbreEntiteGeographiqueObservationFiltreVue;
import org.tela_botanica.client.vues.observation.filtres.ArbreMotsClesObservationVue;
import org.tela_botanica.client.vues.observation.filtres.RechercheLibreVue;
 
import com.gwtext.client.core.Ext;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
 
/**
* Panneau contenant les filtres qu'on peut appliquer aux images
*
* @author aurelien
*
*/
public class PanneauFiltresObservationVues extends Panel {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* L'arbre pour la recherche entite geographique
*
*/
private ArbreEntiteGeographiqueObservationFiltreVue arbreEntiteGeographiqueObservationFiltreVue = null;
/**
* L'arbre pour la recherche date
*
*/
private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null;
private ArbreMotsClesObservationVue arbreMotsClesObservationVue = null ;
private RechercheLibreVue rechercheLibreVue = null;
 
/**
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
*/
@SuppressWarnings("unused")
private PanneauFiltresObservationVues() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer
*/
public PanneauFiltresObservationVues(ObservationMediateur obs) {
super("Filtres");
observationMediateur = obs;
this.setCollapsible(true);
//this.setLayout(new AnchorLayout()) ;
this.setLayout(new RowLayout());
rechercheLibreVue = new RechercheLibreVue(observationMediateur);
if(Ext.isIE()) {
add(rechercheLibreVue);
rechercheLibreVue.setHeight(110);
} else {
add(rechercheLibreVue,new RowLayoutData(100));
}
rechercheLibreVue.setWidth("100%") ;
rechercheLibreVue.setBorder(false);
arbreEntiteGeographiqueObservationFiltreVue = new ArbreEntiteGeographiqueObservationFiltreVue(observationMediateur);
add(arbreEntiteGeographiqueObservationFiltreVue,new RowLayoutData());
//arbreEntiteGeographiqueObservationFiltreVue.setHeight(300) ;
arbreEntiteGeographiqueObservationFiltreVue.setWidth("100%") ;
arbreEntiteGeographiqueObservationFiltreVue.setBorder(false);
arbreDateObservationFiltreVue = new ArbreDateObservationFiltreVue(observationMediateur) ;
//arbreDateObservationFiltreVue.setHeight(300) ;
add(arbreDateObservationFiltreVue, new RowLayoutData());
arbreDateObservationFiltreVue.setWidth("100%") ;
arbreDateObservationFiltreVue.setBorder(false);
arbreMotsClesObservationVue = new ArbreMotsClesObservationVue(observationMediateur);
add(arbreMotsClesObservationVue, new RowLayoutData());
arbreMotsClesObservationVue.setWidth("100%") ;
arbreMotsClesObservationVue.setTitle("Projets");
arbreMotsClesObservationVue.setTitleCollapse(true);
arbreMotsClesObservationVue.setCollapsible(true);
arbreMotsClesObservationVue.setBorder(false);
}
 
/**
* Accesseur pour le filtre des mots clés
*
* @return le filtre des mots clés
*/
public ArbreEntiteGeographiqueObservationFiltreVue getArbreEntiteGeographiqueObservationFiltreVue() {
return arbreEntiteGeographiqueObservationFiltreVue;
}
public ArbreDateObservationFiltreVue getArbreDateObservationFiltreVue() {
return arbreDateObservationFiltreVue;
}
public ArbreMotsClesObservationVue getArbreMotsClesObservationVue() {
return arbreMotsClesObservationVue;
}
public RechercheLibreVue getRechercheLibreVue() {
return rechercheLibreVue;
}
/**
* Renvoie un booléen indiquant si un des filtres a été modifié
*
* @return true sur un des filtres est modifié, false sinon
*/
public boolean renvoyerEtatFiltre() {
 
return (arbreEntiteGeographiqueObservationFiltreVue.renvoyerEtatFiltre() || arbreDateObservationFiltreVue.renvoyerEtatFiltre() || rechercheLibreVue.renvoyerEtatFiltre());
}
 
/**
* Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre",
* "valeur"
*
* @return un tableau contenant les noms et les valeurs à filtrer
*/
public String[][] renvoyerValeursAFiltrer() {
String[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreMotsClesObservationVue.renvoyerValeursAFiltrer(),
rechercheLibreVue.renvoyerValeursAFiltrer()
};
return filtres;
}
public void viderFiltres() {
arbreEntiteGeographiqueObservationFiltreVue.viderFiltre();
arbreDateObservationFiltreVue.viderFiltre();
arbreMotsClesObservationVue.viderFiltre();
rechercheLibreVue.viderFiltre();
}
public void viderFiltres(String nom) {
if(nom.equals("id_mots_cles")) {
arbreMotsClesObservationVue.viderFiltre();
}
if(nom.equals("recherche")) {
rechercheLibreVue.viderFiltre();
}
if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) {
arbreDateObservationFiltreVue.viderFiltre(nom);
}
if(nom.equals("station") || nom.equals("lieudit") || nom.equals("departement") || nom.equals("commune")) {
arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(nom);
}
 
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java
New file
0,0 → 1,105
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventObject;
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;
 
public class MenuObservationVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur;
 
/**
* Item pour la suppression d'obs
*/
private Item supprimerObservation = null;
private Item transmettreObservation = null;
private Item deTransmettreObservation = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuObservationVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuObservationVue(ObservationMediateur om) {
super();
 
oMediateur = om;
transmettreObservation = new Item("Rendre publiques les observations séléctionnées");
addItem(transmettreObservation);
deTransmettreObservation = new Item("Rendre privées les observations séléctionnées");
addItem(deTransmettreObservation);
supprimerObservation = new Item("Supprimer les observations séléctionnées");
addItem(supprimerObservation);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la suppression
if (item.equals(supprimerObservation)) {
// on notifie le médiateur
getOMediateur().supprimerObservations();
}
// si c'est la transmission
if (item.equals(transmettreObservation)) {
// on notifie le médiateur
getOMediateur().transmettreObservations(true);
}
// si c'est la detransmission
if (item.equals(deTransmettreObservation)) {
// on notifie le médiateur
getOMediateur().transmettreObservations(false);
}
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ObservationMediateur getOMediateur() {
return oMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java
New file
0,0 → 1,369
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.form.Label;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.google.maps.gwt.client.GoogleMap;
import com.google.maps.gwt.client.GoogleMap.ClickHandler;
import com.google.maps.gwt.client.GoogleMap.ZoomChangedHandler;
import com.google.maps.gwt.client.InfoWindow;
import com.google.maps.gwt.client.InfoWindowOptions;
import com.google.maps.gwt.client.LatLng;
import com.google.maps.gwt.client.MapOptions;
import com.google.maps.gwt.client.MapTypeId;
import com.google.maps.gwt.client.Marker;
import com.google.maps.gwt.client.MarkerOptions;
import com.google.maps.gwt.client.MouseEvent;
 
public class CartographieObservationVue extends Panel implements Rafraichissable {
 
private String id = "cartographie_observation";
private ObservationMediateur oMediateur = null;
Panel panneauCarto = null;
GoogleMap map = null;
Marker nmk = null;
private boolean carteAjoutee = false;
private boolean infoOuverte = false;
String valeurCommune = "Bourges"; // j'aurais préféré Bort-les-Orgues
LatLng centreFrance = null;
LatLng pointCommune = null;
String codeCommune = "";
int niveauZoom = 6;
 
Label panneauExplication = new Label(
"Précisez le lieu de votre observation et cliquez sur OK. Les coordonnées sont données en degrés décimaux, comptés positivement vers le Nord pour la latitude, et vers l'Est pour la longitude");
 
private InfoWindow info;
private boolean zoomerSurRetour = false;
 
public CartographieObservationVue(ObservationMediateur om) {
 
oMediateur = om;
setHeader(false);
setAutoWidth(true);
setPaddings(10);
 
panneauCarto = new Panel();
panneauCarto.setLayout(new FitLayout());
 
setLayout(new RowLayout());
panneauCarto.setAutoHeight(true);
add(panneauExplication, new RowLayoutData(12));
add(panneauCarto, new RowLayoutData());
addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
initialiserCarte(false);
}
});
}
public void setTailleCarte(int hauteur, int largeur) {
setSize(largeur, hauteur);
}
public void masquerChargement(boolean masquer) {
if(panneauCarto.isVisible()) {
if(masquer) {
panneauCarto.getEl().mask("Recherche des coordonnées et de la commune, veuillez patienter");
} else {
panneauCarto.getEl().unmask();
}
}
}
public void obtenirInfosCommunes(LatLng coord) {
oMediateur.obtenirInformationCoord(this, coord.lat(), coord.lng());
}
 
public void mettreAJourInfos(final LatLng pointNouvelleCommune, String infosComplementaires, int zoom) {
GoogleMap mapNulle = null;
if(nmk != null) {
nmk.setMap(mapNulle);
}
pointCommune = pointNouvelleCommune;
nmk = fabriquerMarqueur(pointCommune, infosComplementaires);
nmk.setMap(map);
afficherInfoMarker(nmk);
recentrerCarte(nmk.getPosition());
map.setZoom(zoom);
}
 
private void initialiserCarte(boolean commune) {
 
panneauCarto.clear();
 
centreFrance = LatLng.create(47.0504, 2.2347);
pointCommune = centreFrance;
 
MapOptions options = MapOptions.create();
options.setCenter(centreFrance);
options.setZoom(6);
options.setMapTypeId(MapTypeId.HYBRID);
options.setDraggable(true);
options.setMapTypeControl(true);
options.setScaleControl(true);
options.setScrollwheel(true);
 
map = GoogleMap.create(panneauCarto.getElement(), options );
InfoWindowOptions infopts = InfoWindowOptions.create();
info = InfoWindow.create();
info.setOptions(infopts);
info.addCloseClickListener(new InfoWindow.CloseClickHandler() {
@Override
public void handle() {
infoOuverte = false;
}
});
if(!commune) {
fabriquerMarqueurIndication();
}
map.addClickListener(new ClickHandler() {
@Override
public void handle(MouseEvent event) {
obtenirInfosCommunes(event.getLatLng());
}
});
map.addZoomChangedListener(new ZoomChangedHandler() {
@Override
public void handle() {
niveauZoom = (int)map.getZoom();
}
});
panneauCarto.doLayout();
panneauCarto.expand();
panneauCarto.setHeight("100%");
panneauCarto.setWidth("100%");
expand();
}
public void fabriquerMarqueurIndication() {
GoogleMap mapNulle = null;
if(nmk != null) {
nmk.setMap(mapNulle);
}
nmk = fabriquerMarqueur(pointCommune,"");
nmk.setMap(map);
info.setContent("<div id=\"info_contenu\">"+
"Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />"
+"longitude="
+ Util.tronquerNombrePourAffichage("" + nmk.getPosition().lng(), 5) + "<br />latitude="
+ Util.tronquerNombrePourAffichage("" + nmk.getPosition().lat(), 5) + "</div>");
infoOuverte = true;
info.open(map,nmk);
}
 
public void AfficherMessageAucuneInfos() {
mettreAJourInfos(centreFrance,"", niveauZoom);
Window.alert("Aucune information pour le nom donné");
}
 
public int getNiveauZoom() {
return niveauZoom;
}
private void ajouterListenerBouton(final String idBouton) {
final ExtElement bouton = Ext.get(idBouton);
if(bouton == null) {
Timer t = new Timer() {
@Override
public void run() {
ajouterListenerBouton(idBouton);
}
};
t.schedule(500);
return;
} else {
bouton.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
EntiteGeographiqueObservation infosCommune = new EntiteGeographiqueObservation(codeCommune,valeurCommune,null,null);
infosCommune.setLat(pointCommune.lat()+"");
infosCommune.setLon(pointCommune.lng()+"");
oMediateur.rafraichirSaisieCommuneObservation(infosCommune);
}
});
bouton.focus();
}
}
 
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
 
if (nouvelleDonnees instanceof String) {
if(isVisible()) {
Window.alert((String)nouvelleDonnees);
}
}
 
if (nouvelleDonnees instanceof EntiteGeographiqueObservation) {
oMediateur.afficherFenetreCarto();
EntiteGeographiqueObservation infos = (EntiteGeographiqueObservation) nouvelleDonnees;
Double lat = 0.0;
Double lon = 0.0;
try {
lat = Double.parseDouble(infos.getLat());
lon = Double.parseDouble(infos.getLon());
} catch (NumberFormatException nbe) {
}
LatLng coord = LatLng.create(lat, lon);
// si on a un point, on zoome fort dès le début
if (zoomerSurRetour) {
niveauZoom = 16;
zoomerSurRetour = false;
}
 
String nouvelleValeurCommune = infos.getZoneGeo();
valeurCommune = nouvelleValeurCommune;
codeCommune = Util.convertirChaineZoneGeoVersDepartement(infos.getIdZoneGeo());
pointCommune = coord;
mettreAJourInfos(coord, "", niveauZoom);
}
masquerChargement(false);
}
public Marker fabriquerMarqueur(LatLng pointMarqueur, final String texte) {
// ajout de marqueurs déplacables, qui affichent une bulle d'information
MarkerOptions options = MarkerOptions.create();
options.setDraggable(true);
options.setPosition(pointMarqueur);
final Marker marker = Marker.create(options);
marker.addDragEndListener(new Marker.DragEndHandler() {
@Override
public void handle(MouseEvent event) {
obtenirInfosCommunes(event.getLatLng());
}
});
marker.addDragStartListener(new Marker.DragStartHandler() {
@Override
public void handle(MouseEvent event) {
info.close();
}
});
 
marker.addClickListener(new Marker.ClickHandler() {
@Override
public void handle(MouseEvent event) {
if(infoOuverte) {
info.close();
infoOuverte = false;
} else {
afficherInfoMarker(marker);
infoOuverte = true;
}
}
});
return marker;
}
public void recentrerCarte() {
if(nmk != null && nmk.getVisible()) {
recentrerCarte(nmk.getPosition());
}
}
 
public void recentrerCarte(LatLng point) {
if(this.getWidth() > 12 && this.getHeight() > 24) {
panneauCarto.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 12)+"px");
}
panneauCarto.doLayout();
panneauCarto.expand();
panneauCarto.setHeight("100%");
panneauCarto.setWidth("100%");
expand();
map.setCenter(point);
}
 
public boolean isCarteAjoutee() {
return carteAjoutee;
}
public void afficherInfoMarker(Marker marker) {
final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>";
 
String contenuMarker = "";
if(valeurCommune == null || valeurCommune.trim().equals("")) {
if(marker.getPosition().lng() == 0 && marker.getPosition().lat() == 0) {
LatLng point = centreFrance;
marker.setPosition(point);
niveauZoom = 6;
}
contenuMarker = "<div id=\"info_contenu\">"+
"Aucun nom de lieu trouvé à cet emplacement <br />"
+"Déplacez ce marqueur pour localiser votre observation (nom de lieu et coordonnées)<br />"
+"longitude="
+ Util.tronquerNombrePourAffichage("" + marker.getPosition().lng(), 5) + "<br />latitude="
+ Util.tronquerNombrePourAffichage("" + marker.getPosition().lat(), 5) + "</div>";
} else {
contenuMarker = ""
+valeurCommune+" ("+codeCommune+")<br />"
+"longitude="
+ Util.tronquerNombrePourAffichage("" + marker.getPosition().lng(), 5) + "<br />latitude="
+ Util.tronquerNombrePourAffichage("" + marker.getPosition().lat(), 5) ;
}
info.setContent(contenuMarker+ htmlBoutonOk);
info.open(map, marker);
info.addDomReadyListenerOnce(new InfoWindow.DomReadyHandler() {
@Override
public void handle() {
ajouterListenerBouton("okMap");
}
});
recentrerCarte(marker.getPosition());
}
 
public double[] getCoordsCentreFrance() {
double[] coords = {47.0504, 2.2347};
return coords;
}
 
public void setDoitZoomerSurRetour(boolean b) {
zoomerSurRetour = b;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/EtatConnexionVue.java
New file
0,0 → 1,279
/**
David Delon david.delon@clapas.net 2007
*/
 
/*
* EtatConnexionVue.java : affichage information portant sur le statut de la connexion utilisateur
*
*
* 1: Le programme affiche le statut connecte si l'utilisateur s'est connecte precedemment, sinon s'affiche le statut deconnecte
* 2: Le programme arme les actions liees a la connection ou a la deconnection
* - Connection : affichage de la boite de connexion
* - Deconnexion : appel du service de deconnexion, et appel de la re-initialisation de l'affichage pour le nouvel identifiant utilisateur obtenu (identifiant de session)
*/
 
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.modeles.objets.Configuration;
 
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
 
/**
* Un indicateur d'etat de connexion
*
* @author David Delon
*
*/
 
public class EtatConnexionVue extends Panel {
 
/**
* Médiateur associé à la vue
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* Texte lié à la connexion.
*
*/
private String labelEtatConnexion = null;
 
/**
* Ouh c'est pas beau, ça ! Mais avec Google Web Toolshit, ça
* marche toujours mieux que quand on fait des trucs beaux :-)
*/
private String liens = "<div id=\"liensExt\">"
+ "<a id=\"lienRemarques\" title=\"Adressez-nous vos remarques ou signalez-nous un problème\""
+ " href=\"" + Configuration.getRemarquesBaseUrl() + "?email=" + Configuration.getEmailContact()
+ "&pageSource=" + URL.encodeQueryString(Window.Location.getHref()) + "\""
+ " onClick=\"javascript:window.open(this.getAttribute('href'), 'Tela Botanica - Remarques', config='height=700, width=640, scrollbars=yes, resizable=yes'); return false;\""
+ " target=\"_blank\""
+ ">Remarques</a>"
+ "<a href=\"#\" id=\"lienAide\">Aide</a>"
+ "</div>" ;
/**
* Booleen indiquant si utilisateur est connecte
*
*/
public EtatConnexionVue(CarnetEnLigneMediateur cm) {
carnetEnLigneMediateur=cm;
 
this.setBodyBorder(false) ;
this.setBorder(false) ;
this.setId("panneau_etat_connexion");
// Pas de word wrap
labelEtatConnexion="";
this.setHtml(labelEtatConnexion+liens);
 
ajouterListeners();
}
public void ajouterListeners() {
ExtElement lienAide = Ext.get("lienAide");
if(lienAide != null)
{
lienAide.removeAllListeners();
lienAide.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
String aideUrl = Configuration.getAideBaseUrl() ;
Window.open(aideUrl, "", "") ;
}
});
}
else
{
addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
ExtElement lienAide = Ext.get("lienAide");
if(lienAide != null)
{
lienAide.removeAllListeners();
lienAide.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
String aideUrl = Configuration.getAideBaseUrl() ;
Window.open(aideUrl, "", "") ;
}
});
}
}
});
}
}
 
/**
* Affichage de l'etat de connexion
* @param text
* @param connecte
*/
public void setEtat(String identifiant, boolean connecte) {
 
if(connecte) {
labelEtatConnexion = "<div id=\"etatConnexion\">Connecté en tant que "+identifiant+" <a id=\"lienDeconnexion\" href=\"#\">(deconnexion)</a>" ;
labelEtatConnexion += "</div>" ;
labelEtatConnexion += liens ;
setHtml(labelEtatConnexion);
 
ExtElement lienDeco = Ext.get("lienDeconnexion");
if(lienDeco != null)
{
lienDeco.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
carnetEnLigneMediateur.deconnecterUtilisateur();
}
});
}
else
{
addListener(new ContainerListenerAdapter()
{
@Override
public void onAfterLayout(Container c)
{
ExtElement lienDeco = Ext.get("etatConnexion");
lienDeco.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
carnetEnLigneMediateur.deconnecterUtilisateur();
setEtat(null, false);
}
});
}
});
}
}
else
{
labelEtatConnexion = "<div id=\"etatConnexion\"> Utilisez ce carnet en ligne pour saisir vos observations, <a id=\"lienConnexion\" href=\"#\">identifiez-vous</a> pour les transmettre à Tela Botanica</div>";
labelEtatConnexion += liens ;
setHtml(labelEtatConnexion);
ExtElement lienCo = Ext.get("etatConnexion");
if(lienCo != null) {
lienCo.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
carnetEnLigneMediateur.afficherDialogueConnexion();
}
});
}
else
{
addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
ExtElement lienCo = Ext.get("etatConnexion");
lienCo.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
carnetEnLigneMediateur.afficherDialogueConnexion();
}
});
}
});
}
}
ExtElement lienAide = Ext.get("lienAide");
if(lienAide != null)
{
lienAide.removeAllListeners();
lienAide.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
String aideUrl = Configuration.getAideBaseUrl() ;
Window.open(aideUrl, "", "") ;
}
});
}
else
{
addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
ExtElement lienAide = Ext.get("lienAide");
if(lienAide != null)
{
lienAide.removeAllListeners();
lienAide.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
String aideUrl = Configuration.getAideBaseUrl() ;
Window.open(aideUrl, "", "") ;
}
});
}
}
});
}
 
}
 
}
 
 
/* +--Fin du code ---------------------------------------------------------------------------------------+
* $Log$
* Revision 1.1 2008-11-13 11:27:05 ddelon
* Reecriture gwt-ext
*
* Revision 1.1 2008-06-09 14:19:37 ddelon
* Initialisation observation
*
* Revision 1.2 2008-04-28 13:10:44 ddelon
* Integration MyGwt
*
* Revision 1.1 2008-01-02 21:26:04 ddelon
* mise en place mygwt
*
* Revision 1.6 2007-12-22 14:48:53 ddelon
* Documentation et refactorisation
*
* Revision 1.5 2007-09-17 19:25:34 ddelon
* Documentation
*
*
*/
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
New file
0,0 → 1,204
/**
David Delon david.delon@clapas.net 2007
*/
 
/*
* LoginDialog.java (DialogBox)
*
* Cas d'utilisation :
* Dialogue de validation de l'identification utilisateur
*
* 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe
* 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies
* 3 : Le dialogue transmet au systeme local les informations d'identification
* 3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4.
* 4 : Cloture du dialogue
* 5 : Appel du dialogue d'importation
*/
 
package org.tela_botanica.client.vues;
 
// TODO : controle de forme sur saisie (regex integree) ...
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
 
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.KeyboardListener;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Position;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.TextField;
 
public class FormulaireDeConnexionVue extends DialogBox {
 
/**
* Médiateur associé à la vue
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* email saisi
*/
private TextField ident=null;
/**
* mot de passe saisi
*/
private TextField motDePasse=null;
private Label saisieInvalide = null ;
 
public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) {
carnetEnLigneMediateur=cm;
setStyleName("popup_connexion");
 
Panel panneauPrincipalDialogue=new Panel();
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
panneauFormulaire.setTitle("Connexion");
panneauFormulaire.setWidth(350);
panneauFormulaire.setLabelWidth(100);
// Email
ident = new TextField("Mail", "ident", 200);
ident.setAllowBlank(false);
ident.setInvalidText("Mail vide ou incorrect");
ident.setTabIndex(800);
panneauFormulaire.add(ident);
// Mot de passe
motDePasse = new TextField("Mot de passe", "motDePasse", 200);
motDePasse.setAllowBlank(false);
ident.setInvalidText("Mot de passe vide ou incorrect");
motDePasse.setPassword(true);
motDePasse.setTabIndex(801);
panneauFormulaire.add(motDePasse);
 
Button boutonOK = new Button("Ok");
boutonOK.setTabIndex(802);
panneauFormulaire.addButton(boutonOK);
Button boutonAnnuler = new Button("Annuler");
boutonAnnuler.setTabIndex(803);
panneauFormulaire.addButton(boutonAnnuler);
// Click sur bouton de validation
boutonOK.addListener(
new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText());
}
}
);
// Click sur bouton d'annulation
boutonAnnuler.addListener(
new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
cacher();
}
}
);
 
// Email
// gestion de la touche entrée
ident.addKeyListener(EventObject.ENTER, new KeyListener() {
 
@Override
public void onKey(int key, EventObject e) {
carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText());
}
});
// Mot de passe
motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() {
 
@Override
public void onKey(int key, EventObject e) {
carnetEnLigneMediateur.connecterUtilisateur(ident.getText(),motDePasse.getText());
}
});
saisieInvalide = new Label("");
saisieInvalide.setStyleName("saisie_invalide_invisible");
panneauFormulaire.add(saisieInvalide);
panneauPrincipalDialogue.add(panneauFormulaire);
setWidget(panneauPrincipalDialogue);
}
/*
* On sort sur touche echappement
*/
@Override
public boolean onKeyDownPreview(char key, int modifiers) {
switch (key) {
case KeyboardListener.KEY_ESCAPE:
hide();
break;
}
 
return true;
}
 
public void afficherMessageAlerte() {
saisieInvalide.setText("Identifiant ou mot de passe invalide");
saisieInvalide.setStyleName("saisie_invalide");
}
 
 
public void cacher() {
saisieInvalide.setText("");
saisieInvalide.setStyleName("saisie_invalide_invisible");
hide();
}
}
 
/* +--Fin du code ---------------------------------------------------------------------------------------+
* $Log$
* Revision 1.1 2008-11-13 11:27:05 ddelon
* Reecriture gwt-ext
*
* Revision 1.1 2008-06-09 14:19:37 ddelon
* Initialisation observation
*
* Revision 1.10 2007-09-17 19:25:34 ddelon
* Documentation
*
* Revision 1.9 2007-05-21 21:03:44 ddelon
* nettoyage de code
*
* Revision 1.8 2007-05-21 18:14:06 ddelon
* Gestion importation releve locaux
*
* Revision 1.7 2007-05-21 11:47:30 ddelon
* meta cvs
*
* Revision 1.6 2007-05-21 11:39:48 ddelon
* meta cvs
*
* Revision 1.5 2007-05-21 11:39:12 ddelon
* meta cvs
*
* Revision 1.4 2007-05-21 11:37:35 ddelon
* meta cvs
*
* Revision 1.3 2007-05-21 11:36:51 ddelon
* meta cvs
*
*/
/branches/v2.8-houe/src/org/tela_botanica/client/vues/MiniBarrePaginationVue.java
New file
0,0 → 1,321
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Template;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
 
public class MiniBarrePaginationVue extends Toolbar implements Rafraichissable {
 
/**
* Instance du médiateur à qui on notifie les évnènements
*/
private ListePaginable listePaginable = null;
 
/**
* Bouton précédent
*/
private ToolbarButton prevPage = new ToolbarButton();
/**
* Bouton suivant
*/
private ToolbarButton suivPage = new ToolbarButton();
/**
* Numéro de la page courante (attention, commence à zéro pour des raisons
* pratiques)
*/
private int pageCourante = 0;
/**
* Nombre de page total
*/
private int pageTotale = 1;
/**
* Nombre d'élements total
*/
private int nbElement = 0;
/**
* Nombre d'élément par page
*/
private int taillePage = 0;
/**
* Texte statique de la toolbar 2
*/
private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ");
/**
* Combobox permettant de selectionner le nombre d'élements à afficher par
* page et donc de changer la variable taillePage
*/
private ComboBox selecteurTaillePage = new ComboBox();
/**
* Les différents intervalles de page possibles (intialisé par défaut)
*/
String[] pages = { "200","100","50", "20", "10" };
Store storeIntervalle = null ;
 
/**
* Label indiquant le type d'element affiché
*
*/
 
private String labelElement="Elements";
 
/**
* taille de la page par defaut
*
*/
 
private int taillePageDefaut = 50;
 
/**
* Texte statique de la toolbar 3
*/
private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
labelElement + " par page ");
 
/**
* retourne la liste associé à la barre
*/
public ListePaginable getlistePaginable() {
return listePaginable;
}
 
/***************************************************************************
* constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private MiniBarrePaginationVue() {
super();
}
 
/**
* constructeur avec paramètres
*
* @param im
* le médiateur à associer à la barre
*/
public MiniBarrePaginationVue(ListePaginable lst) {
super();
 
listePaginable = lst;
// on dispose un peu de texte et quelques espaces pour séparer les
// éléments
addButton(prevPage);
addSpacer();
addButton(suivPage);
 
addSpacer();
addItem(afficherNbElem);
 
prevPage.setIcon("page_prev.png");
suivPage.setIcon("page_suiv.png");
 
setIntervallesPages(pages) ;
 
// le template definit ce que l'on affiche pour chaque element du store
// dans la combobox
final Template tp = new Template("<div class=\"x-combo-list-item\">"
+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
tp.compile();
 
selecteurTaillePage.setTpl(tp);
selecteurTaillePage.setStore(storeIntervalle);
selecteurTaillePage.setEditable(false);
addField(selecteurTaillePage);
selecteurTaillePage.setValue(""+taillePageDefaut);
selecteurTaillePage.setWidth(50);
addItem(nbElemParPage);
 
// on ajoute les différents listeners
ajouterListeners();
}
 
/**
* Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
* @param label
*/
public void setLabelElement(String label) {
this.labelElement = label;
nbElemParPage.setText(labelElement + " par page ");
}
 
public void setTaillePageParDefaut(int taille) {
this.taillePageDefaut = taille;
selecteurTaillePage.setValue(""+taillePageDefaut);
}
public void setIntervallesPages(String[] intervalle)
{
String[][] intervallesPages = new String[intervalle.length][1] ;
for(int i = 0 ; i < intervalle.length ; i++)
{
intervallesPages[i][0] = intervalle[i] ;
}
storeIntervalle = new SimpleStore(new String[] { "nb_page" },
intervallesPages );
storeIntervalle.load();
selecteurTaillePage.setStore(storeIntervalle);
}
/**
* ajoute les différents listeners nécessaires au bon fonctionnement des
* éléments de la barre de pagination
*/
private void ajouterListeners() {
// boutons suivants et précédents
prevPage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
 
// si la page courante n'est pas la première
if (pageCourante > 0) {
// on décrémente la page courante de 1
pageCourante--;
// on rafraichit l'affichage
// et on notifie le médiateur de l'évenement
listePaginable.changerNumeroPage(pageCourante);
 
}
}
});
 
suivPage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
// si la page courante n'est pas la dernière
if (pageCourante < pageTotale - 1) {
// on incrémente la page courante de 1
pageCourante++;
// on rafraichit l'affichage
// et on notifie le médiateur de l'évenement
listePaginable.changerNumeroPage(pageCourante);
 
}
}
});
 
// listener pour la selection dans la combobox
selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
 
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
 
String nouvelleTaillePageString = comboBox.getStore()
.getRecordAt(index).getAsString("nb_page");
int nouvelleTaillePage = Integer
.parseInt(nouvelleTaillePageString);
 
// si la taille de page est différente de l'ancienne
if (nouvelleTaillePage != taillePage) {
// on la change
changerTaillePage(nouvelleTaillePage);
}
// et on met la valeur à jour dans la combobox
comboBox.setValue(nouvelleTaillePageString);
}
 
});
}
 
/**
* Met à jour la page en cours
*
* @param nouvellePageCourante
* la nouvelle page en cours
*/
public void changerPageCourante(int nouvellePageCourante) {
pageCourante = nouvellePageCourante;
}
 
/**
* Methode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on reçoit un tableau de int
if (nouvelleDonnees instanceof int[]) {
int[] page = (int[]) nouvelleDonnees;
// le premier élement est le nombre de pages totales
pageTotale = page[0];
// le second la page en cours
pageCourante = page[1];
// le troisième la taille de la page
taillePage = page[2];
// et le dernier le nombre total d'éléments
nbElement = page[3];
 
// si la page courante dépasse la page totale (cas normalement
// improbable car géré en amont)
// on met le numéro de page à la page courante -1 (car la page
// courante est comptée à partir
// de zéro)
if (pageCourante >= pageTotale && pageCourante != 0) {
pageCourante = pageTotale - 1;
// le cas échéant on en notifie le médiateur
listePaginable.changerNumeroPage(pageCourante);
}
}
}
 
/**
* Renvoie les différents intervalles de pages possibles
*
* @return un tableau de string qui contient les différentes
* taille de pages
*/
public String[] getNbPages() {
return pages;
}
 
/**
* Envoie au médiateur une demande pour modifier la taille de la page (qui
* va à son tour faire les modifications nécessaires)
*
* @param nouvelleTaillePage
* la nouvelle taille de page (élement appartenant au tableau
* renvoyé par getNbPages())
*/
public void changerTaillePage(int nouvelleTaillePage) {
listePaginable.changerTaillePage(nouvelleTaillePage);
}
 
/**
* Selectionne la valeur correspond à celle passée en paramètre dans la
* combobox (si elle existe)
*
* @param nouvelleTaillePage
* la nouvelle taille de page
*/
public void selectionnerTaillePage(int nouvelleTaillePage) {
selecteurTaillePage.setValue("" + nouvelleTaillePage);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/ImageMotsClesVue.java
New file
0,0 → 1,96
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.widgets.Panel;
 
/**
* Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
* clés cochables et réorganisables à volonté
*
* @author aurelien
*
*/
public class ImageMotsClesVue extends Panel implements Rafraichissable {
 
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par
* des virgules
*/
private String motsClesEnCours = "";
private String[] tableauMotsClesEnCours = new String[0];
/**
* Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
* (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
* du conteneur n'ai été effectué)
*/
private String[] motsClesEnAttente = new String[0];
private HTML motsClesAffiches = new HTML();
 
/**
* Constructeur sans paramètre (privé car interdit d'utilisation)
*/
@SuppressWarnings("unused")
private ImageMotsClesVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public ImageMotsClesVue(ImageMediateur im) {
// on crée le panel
super("Mots clés");
this.setHeight("100%");
this.add(motsClesAffiches);
motsClesAffiches.setHeight("100%");
this.setBorder(false);
this.setBodyBorder(false);
this.setCollapsible(true);
this.setTitleCollapse(true);
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données pour l'objet
* @param repandreRafraichissement
* booleen qui dit si on doit répandre l'évenement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
// Si on reçoit un tableau de String (cas ou l'on séléectionne une
// nouvelle image)
if (nouvelleDonnees instanceof String[]) {
 
// le tableau de String contient les id des mots clés associés à
// l'image
// on affiche les mots clés contenu dans le tableau
tableauMotsClesEnCours = (String[]) nouvelleDonnees;
afficherMotsCles(tableauMotsClesEnCours);
}
}
 
private void afficherMotsCles(String[] tableauMotsClesEnCours) {
motsClesEnCours = "<ul class=\"liste_mots_cles\">";
for (int i = 0; i < tableauMotsClesEnCours.length; i++) {
if(!tableauMotsClesEnCours[i].trim().isEmpty()) {
motsClesEnCours += "<li>"+tableauMotsClesEnCours[i]+"</li>";
}
}
motsClesEnCours += "</ul>";
motsClesAffiches.setHTML(motsClesEnCours);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/MenuIdVue.java
New file
0,0 → 1,85
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
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;
 
public class MenuIdVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour le changement d'utilisateur
*/
private Item changerId = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuIdVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuIdVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
// on construit le menu
changerId = new Item("Changer d'utilisateur");
addItem(changerId);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la recherche par commentaires
if (item.equals(changerId)) {
// on notifie le médiateur
getIMediateur().afficherMenuId();
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/OptionsImages.java
New file
0,0 → 1,211
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
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.MenuItem;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
public class OptionsImages {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour l'upload
*/
private MenuItem uploaderImage = null;
/**
* Item pour la suppression
*/
private ToolbarButton supprimerImage = null;
 
/**
* Item pour l'ajout d'images à la selection
*/
private Item ajouterImageSelection = null;
 
/**
* Item pour vider la selection d'images
*/
private Item viderSelection = null;
 
/**
* Item pour lier la selection d'images
*/
private Item afficherSelection = null;
private Item uploadMultiple = null ;
private Item uploadSimple = null ;
private Menu mnFichiers = null ;
private Menu mnTampon = null ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private OptionsImages() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public OptionsImages(ImageMediateur im) {
super();
 
iMediateur = im;
mnFichiers = new Menu();
uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois");
uploadSimple = new Item("Un fichier à la la fois");
mnFichiers.addItem(uploadMultiple);
mnFichiers.addItem(uploadSimple);
 
// on construit le menu
uploaderImage = new MenuItem("Ajouter des images", mnFichiers);
supprimerImage = new ToolbarButton("Supprimer");
ajouterImageSelection = new Item(
"Ajouter les images sélectionnées au tampon");
viderSelection = new Item("vider le contenu du tampon");
afficherSelection = new Item("Supprimer le contenu du tampon");
mnTampon = new Menu();
mnTampon.addItem(ajouterImageSelection);
mnTampon.addItem(viderSelection);
mnTampon.addItem(afficherSelection);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
mnTampon.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est l'ajout à la sélection
if (item.equals(ajouterImageSelection)) {
getIMediateur().ajouterImagesSelection();
}
 
// si c'est le vidage de la sélection
if (item.equals(viderSelection)) {
getIMediateur().viderSelection();
}
 
// si c'est l'affichage de la selection
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
// enfin, on cache le menu
mnTampon.hide();
 
}
@Override
public void onShow(Menu menu) {
if(getIMediateur().getCompteSelection() != 0) {
afficherSelection.enable();
viderSelection.enable();
}
else {
afficherSelection.disable();
viderSelection.disable();
}
}
 
});
mnTampon.setTitle("Permet de sélectionner et d'afficher des images présentes sur plusieurs pages");
// si c'est la suppression
supprimerImage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button b, EventObject e) {
// on notifie le médiateur
getIMediateur().supprimerImages();
}
});
supprimerImage.setTitle("Supprimer les images sélectionnées");
mnFichiers.addListener(new MenuListenerAdapter() {
@Override
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'upload
if (item.equals(uploadMultiple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(true);
}
// si c'est l'upload
if (item.equals(uploadSimple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(false);
}
}
});
mnFichiers.setTitle("Ajouter des images en les selectionnant une par une ou bien un dossier à la fois");
}
public Menu getMenuImage() {
return mnFichiers;
}
public Menu getMenuTampon() {
return mnTampon;
}
public ToolbarButton getBoutonSuppression() {
return supprimerImage;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/ListeImageVue.java
New file
0,0 → 1,745
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
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.vues.BarrePaginationVue;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.RowSelectionModel;
import com.gwtext.client.widgets.grid.event.GridRowListener;
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
 
/**
* Liste d'image composée de miniatures et d'information sur l'image, implémente
* l'interface rafraichissable et l'interface vueListable
*
* @author aurelien
*/
public class ListeImageVue extends GridPanel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Config de colonne
*/
private ColumnConfig numImage;
/**
* Config de colonne
*/
private ColumnConfig transmisImage;
/**
* Config de colonne
*/
private ColumnConfig urlImage;
/**
* Config de colonne
*/
private ColumnConfig lieImage;
/**
* Config de colonne
*/
private ColumnConfig datImage;
/**
* Config de colonne
*/
private ColumnConfig appImage;
/**
* Config de colonne
*/
private ColumnConfig noteImage;
/**
* Config de colonne
*/
private ColumnConfig nomImage;
/**
* Config de colonne
*/
private ColumnConfig obsAssociees;
/**
* Modele de colonnes
*/
private ColumnModel modeleColonnes;
 
/**
* Booleen d'instanciation
*/
private boolean estInstancie = false;
 
/**
* Store qui contient les données à afficher
*/
private Store st = null;
/**
* Configuration des colonnes du store
*/
private ColumnConfig cl = null;
 
/**
* Barre de pagination
*/
private BarrePaginationVue bt = null;
/**
* Taille max des images dans la liste
*/
private int tailleOr = 50 ;
 
/**
* Garder ou non l'aspet original des images
*/
private boolean garderRatio = true;
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
private ListeImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer
*/
public ListeImageVue(ImageMediateur im) {
 
new ListeImageVue();
 
this.setId("listeImageGrid");
// on associe le médiateur
this.iMediateur = im;
 
// on place la barre de pagination
bt = new BarrePaginationVue(this);
bt.setLabelElement("Images");
bt.setTaillePageParDefaut(50);
setBottomToolbar(bt);
 
// on construit le modèle de colonnes
numImage = new ColumnConfig("Numéro", "num_image", 30, true,
new Renderer() {
 
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String ImgNum = record.getAsString("num_image");
return "<div class=\"centered-list\">" + ImgNum
+ "</div>";
}
 
});
transmisImage = new ColumnConfig(" ", "obs_associees", 10, true, new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
String nomObs = record.getAsString("obs_associees");
if(nomObs == null) {
return "";
}
boolean transmise = estAssocieeTransmise(nomObs)[1];
if(transmise)
{
return "<img src=\"tela.png\"/></img>" ;
}
else
{
return "" ;
}
}
});
 
datImage = new ColumnConfig("Date", "dat_image", 80, true,
new Renderer() {
 
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String ImgDat = record.getAsString("dat_image");
if (ImgDat == null) {
ImgDat = " ";
}
return "<div class=\"centered-list\">" + ImgDat
+ "</div>";
}
 
});
lieImage = new ColumnConfig("Lieu", "lie_image", 120, true,
new Renderer() {
 
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String ImgLie = record.getAsString("lie_image");
if (ImgLie == null) {
ImgLie = " ";
}
return "<div class=\"centered-list\">" + ImgLie
+ "</div>";
}
 
});
appImage = new ColumnConfig("Appareil", "app_image", 120, true,
new Renderer() {
 
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String ImgApp = record.getAsString("app_image");
if (ImgApp == null) {
ImgApp = " ";
}
return "<div class=\"centered-list\">" + ImgApp
+ "</div>";
}
 
});
 
// la colonne url possède une méthode de rendu spéciale
urlImage = new ColumnConfig("Image", "url_image_S", 30, true,
new Renderer() {
 
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
// on affiche une div contenant l'image pointée par
// l'url
int[] XY = {record.getAsInteger("taille_x") ,record.getAsInteger("taille_y")} ;
int[] XYresize = {tailleOr,tailleOr} ;
if(garderRatio) {
XYresize = calculerDimensions(XY);
}
String ImgUrl = record.getAsString("url_image_S");
String ImgNum = record.getAsString("num_image");
return "<div class=\"img-list centered-list\"> <img src=\""
+ ImgUrl + "\" title='" + ImgNum + "' width=\""+XYresize[0]+" px\" height=\""+XYresize[1]+" px\"> </div>";
}
 
});
 
noteImage = new ColumnConfig("Note", "note_image", 80, true,
new Renderer() {
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String htmlImage = "";
 
int noteImg = record.getAsInteger("note_image");
if (noteImg >= 0) {
htmlImage += "<div class=\"img-note centered-list\">";
for (int i = 0; i <= noteImg; i++) {
htmlImage += "<img src=\"note-on.gif\">";
}
htmlImage += "</div>";
}
 
return htmlImage;
 
}
 
});
nomImage = new ColumnConfig("Nom original", "nom_original", 120, true,
new Renderer() {
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String imgNomOr = record.getAsString("nom_original");
if (imgNomOr == null) {
imgNomOr = " ";
}
return "<div class=\"centered-list\">" + imgNomOr
+ "</div>";
}
 
});
obsAssociees = new ColumnConfig("Nom associé", "obs_associees", 80, true,
new Renderer() {
@Override
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
cellMetadata.setCssClass("centered-list");
 
String nomObs = record.getAsString("obs_associees");
if(nomObs == null) {
return "";
}
String nomFormate = getNomsObservationsFormatees(nomObs);
return "<div class=\"centered-list\">" + nomFormate
+ "</div>";
}
 
});
 
// on associe le modèle de colonnes
ColumnConfig[] cm = { numImage, transmisImage, urlImage, obsAssociees, datImage, lieImage, appImage,
noteImage,nomImage} ;
modeleColonnes = new ColumnModel(cm);
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
this.setAutoWidth(true);
this.setEnableColumnResize(true);
 
// creation du store
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defTransmisImage = new IntegerFieldDef("obs_associees");
FieldDef defNomImage = new StringFieldDef("nom_original");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new StringFieldDef("note_image");
FieldDef defTailleX = new IntegerFieldDef("taille_x");
FieldDef defTailleY = new IntegerFieldDef("taille_y");
FieldDef defObsAssociees = new StringFieldDef("obs_associees");
FieldDef[] defTab = { defNumImage,defTransmisImage, defNomImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage, defTailleX, defTailleY, defObsAssociees};
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
this.setStore(st);
this.getView().setAutoFill(true);
 
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("chargement");
//Enable drag and drop
this.setEnableDragDrop(true);
//You need to set the same group for both grids
this.setDdGroup("DragGroupName");
 
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
this.addListener(new ContainerListenerAdapter() {
 
@Override
public void onHide(Component component) {
 
}
 
// lors du premier rendu on demande les données qui sont déjà
// contenues dans la galerie qui est le premier élément affiché
 
@Override
public void onRender(Component component) {
 
if (!isEstInstancie()) {
setEstInstancie(true);
setDragDropText("Glissez les images sur la liste d'observation pour les lier") ;
getIMediateur().synchroniserSelection("galerie");
}
}
 
@Override
public void onShow(Component component) {
 
}
 
});
 
this.addGridRowListener(new GridRowListener() {
 
// gestion du clic sur une ligne
@Override
public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {
// on notifie le médiateur et on lui passe le numéro de ligne
getIMediateur().clicListeImage(rowIndex);
}
 
// gestion du clic droit
@Override
public void onRowContextMenu(GridPanel grid, int rowIndex,
EventObject e) {
// on stoppe l'évenement pour empecher le navigateur d'afficher
// son propre menu
e.stopEvent();
// on notifie le médiateur en lui passant l'évenement
getIMediateur().montrerContextMenu(e);
}
 
// gestion du double clic
@Override
public void onRowDblClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur en lui passant le numéro de ligne
getIMediateur().doubleClicListeImage(rowIndex);
}
});
 
this.getSelectionModel().addListener(new RowSelectionListenerAdapter() {
 
// gestion de la sélection
 
@Override
public void onSelectionChange(RowSelectionModel sm) {
 
// si on a rien de sélectionné
if (sm.getCount() <= 0) {
// on notifie le médiateur (qui désactive notamment l'accès
// à certaines infos)
getIMediateur().aucuneSelection();
} else {
// sinon on notifie le médiateur
getIMediateur().selection();
// et on lui demande de synchroniser la selection avec les
// autres vues
getIMediateur().synchroniserSelection("liste");
}
}
});
//Enable drag and drop
this.setEnableDragDrop(true);
 
//Same name in destination
this.setDdGroup("DragGroupName");
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//Now this is the important part, you need a drop target
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
@Override
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
if(data instanceof GridDragData)
{
GridDragData gdd = (GridDragData)data ;
if(gdd.getGrid().getId().equals("listeImageGrid"))
{
return false ;
}
else
{
return iMediateur.lierObsDD(source, e, data, getId()) ;
}
}
else
{
return false ;
}
}
@Override
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Méthode héritée de l'interface VueListable Sélectionne les images dans la
* galerie suivant les identifiants donnés en paramètres
*/
@Override
public String[] getIdSelectionnees() {
Record[] selection = this.getSelectionModel().getSelections();
int taille = selection.length;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("num_image");
}
 
return id_selection;
}
 
/**
* Accesseur pour la config de colonnes
*
* @return la config de colonnes
*/
public ColumnConfig getCl() {
return cl;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur pour le modèle de colonnes
*
* @return le modèle de colonnes
*/
public ColumnModel getModeleColonnes() {
return modeleColonnes;
}
 
/**
* Accesseur pour le store
*
* @return le store contenant les données
*/
public Store getSt() {
return st;
}
 
/**
* Accesseur pour le booleen d'instanciation
*
* @return le booleen d'instanciation
*/
public boolean isEstInstancie() {
return estInstancie;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen de notification du rafraichissement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit un store
if (nouvelleDonnees instanceof Store) {
 
// on affecte celui-ci comme gestionnaire de données
st = (Store) nouvelleDonnees;
st.load();
// et on reconfigure et rafraichit la vue
this.reconfigure(st, this.getColumnModel());
 
}
 
// si on doit répandre l'évenement
if (repandreRafraichissement) {
// on notifie le médiateur avec une copie des données
getIMediateur().synchroniserDonneesZoomListeGalerie(
nouvelleDonnees, this);
}
}
 
/**
* Sélectionne des enregistrements donné
*
* @param sel
* un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
if (isEstInstancie()) {
getSelectionModel().clearSelections();
getSelectionModel().selectRecords(sel);
}
}
 
/**
* Accesseur pour la toolbar de pagination
*
* @return la toolbar de pagination
*/
public BarrePaginationVue getToolBarVue() {
return bt;
}
 
/**
* Setteur pour le booleen d'instanciation
*
* @param estInstancie
* la nouvelle valeur du booleen
*/
public void setEstInstancie(boolean estInstancie) {
this.estInstancie = estInstancie;
}
 
public void mettreAjourInfos(String commentaires, String date, String note) {
 
for (int i = 0; i < getSelectionModel().getCount(); i++) {
 
getSelectionModel().getSelections()[i].set("note_image", note);
getSelectionModel().getSelections()[i].set("dat_image", date);
 
}
 
}
@Override
public void changerNumeroPage(int pageCourante) {
iMediateur.changerNumeroPage(pageCourante) ;
}
 
@Override
public void changerTaillePage(int nouvelleTaillePage) {
iMediateur.changerTaillePage(nouvelleTaillePage) ;
}
public int[] calculerDimensions(int[] tailleXY) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = this.tailleOr ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
return res;
}
private String getNomsObservationsFormatees(String nomObs) {
String htmlInfobulle = "";
String[][] obs = getObservationsAssociees(nomObs);
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) {
htmlInfobulle += ", "+obs[i][1];
}
}
htmlInfobulle = htmlInfobulle.replaceFirst(", ", "");
return htmlInfobulle;
}
private String[][] getObservationsAssociees(String nomObs) {
if(nomObs.trim().equals("")) {
return new String[0][0];
}
String[] obsTab = nomObs.split(";;");
String[][] obsAnalysees = new String[obsTab.length][3];
for(int i = 0; i < obsTab.length; i++) {
obsAnalysees[i] = obsTab[i].split("#");
}
return obsAnalysees;
}
private boolean[] estAssocieeTransmise(String nomObs) {
String[][] obs = getObservationsAssociees(nomObs);
boolean[] associeesTranmises = {false, false};
if(obs.length > 0) {
associeesTranmises[0] = true;
}
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) {
associeesTranmises[1] = true;
}
}
return associeesTranmises;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java
New file
0,0 → 1,149
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
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.core.EventObject;;
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
public class MenuLiaisonVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour lier la selection d'images aux observations selectionnées
*/
private Item lierSelection = null ;
/**
* Item pour lier la selection d'images aux observations selectionnées
*/
private Item lierSelectionTampon = null ;
 
/**
* Item pour afficher la selection d'images
*/
private Item afficherSelection = null;
/**
* Item pour supprimer la liaison entre une observation et une image
*/
private Item supprimerLiaison = null ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuLiaisonVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuLiaisonVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
lierSelection = new Item("Lier les images selectionnées à la sélection d'observation");
lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation");
afficherSelection = new Item("Afficher le tampon");
addItem(lierSelection);
addItem(lierSelectionTampon);
addItem(afficherSelection);
 
// on ajoute les listeners
ajouterListeners();
}
 
public MenuLiaisonVue(ImageMediateur im, boolean liaison) {
iMediateur = im;
lierSelection = new Item("Lier les images selectionnées à la sélection d'observation");
lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation");
afficherSelection = new Item("Afficher le tampon");
addItem(lierSelection);
addItem(lierSelectionTampon);
addItem(afficherSelection);
iMediateur = im;
if(liaison) {
supprimerLiaison = new Item("Supprimer la liaison") ;
addItem(supprimerLiaison);
}
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la suppression
if (item.equals(lierSelection)) {
// on notifie le médiateur
getIMediateur().LierObservations();
}
// si c'est la suppression
if (item.equals(lierSelectionTampon)) {
// on notifie le médiateur
getIMediateur().LierTamponObservations();
}
 
// si c'est la liaison
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
if(item.equals(supprimerLiaison)) {
getIMediateur().supprimerLiaisonObsImage() ;
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/BarreNotationVue.java
New file
0,0 → 1,237
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.MouseListenerAdapter;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.widgets.Panel;
 
/**
* Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique,
* utilisant Ajax (et pas CSS)
*
* @author aurelien
*
*/
public class BarreNotationVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
@SuppressWarnings("unused")
private ImageMediateur iMediateur = null;
/**
* La note actuellement affichée
*/
private int noteEnCours = 0;
/**
* La note maximum
*/
private int noteMax = 0;
/**
* Booléen indiquant si une note est affectée à la barre en ce moment
*/
private boolean estNote = false;
/**
* Tablmeau d'images contenant les étoiles affichées
*/
private Image[] etoiles = null;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreNotationVue() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer à la vue
* @param noteMax
* la note maximale
*/
public BarreNotationVue(ImageMediateur im, int noteMax) {
iMediateur = im;
setNoteMax(noteMax);
this.setSize(200, 100);
this.setBodyBorder(false);
this.setBorder(false);
this.setCls("x-view-notation");
 
ajouterListeners();
 
}
 
public void ajouterListeners() {
for (int i = 0; i < etoiles.length; i++) {
 
etoiles[i].addMouseListener(new MouseListenerAdapter() {
 
// si la souris passe sur la barre
@Override
public void onMouseEnter(Widget sender) {
 
Image enCours = (Image) sender;
 
// on met en surbrillance toutes les étoiles allant de la
// première jusqu'à
// celle sous le curseur
for (int i = 0; etoiles[i] != enCours; i++) {
etoiles[i].setUrl("note-hover.gif");
}
enCours.setUrl("note-hover.gif");
 
}
 
// si la souris sort de la barre
@Override
public void onMouseLeave(Widget sender) {
 
// on affiche la véritable note
afficherNote();
}
 
});
 
etoiles[i].addClickListener(new ClickListener() {
// si on clique sur une étoiles
@Override
public void onClick(Widget sender) {
 
int i = 0;
 
// on récupère le numéro de l'étoile sur laquelle on a
// cliqué
while (etoiles[i] != (Image) sender) {
i++;
}
// et on affecte la note
noter(i);
 
}
 
});
}
 
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on recoit un tableau de string
if (nouvelleDonnees instanceof String[]) {
// on récupère le premier élément (un entier, qui contient la note)
String[] note = (String[]) nouvelleDonnees;
try {
int noteInt = Integer.parseInt(note[0]);
 
// si l'entier est une note valide
if (noteInt != -1 && noteInt >= 0) {
 
noter(noteInt);
}
// sinon si l'entier vaut -1
else {
// alors on note avec 0
// et on met le booleen de notation a false (qui signifie que
// l'image n'est pas encore notée)
estNote = false;
noteEnCours = 0;
// et demande l'affichage
afficherNote();
}
} catch(NumberFormatException e) {
// rien car pas de note (idem que le cas -1
// alors on note avec 0
// et on met le booleen de notation a false (qui signifie que
// l'image n'est pas encore notée)
estNote = false;
noteEnCours = 0;
// et demande l'affichage
afficherNote();
}
}
 
}
 
/**
* Affecte une note à la barre et rafraichit l'affichage
*
* @param note
* la nouvelle note
*/
public void noter(int note) {
// on affecte la note
noteEnCours = note;
// on met le boolean de notation à true (l'image est notée)
estNote = true;
// et on demande l'affichage
afficherNote();
}
 
/**
* Setteur pour la note maximale
*
* @param nMax
* la nouvelle note maximale
*/
public void setNoteMax(int nMax) {
// on affecte la note
noteMax = nMax;
// on prépare le tableau d'image
etoiles = new Image[noteMax];
 
// qu'on remplit par defaut avec des images d'étoiles vides
for (int i = 0; i < noteMax; i++) {
etoiles[i] = new Image("note-off.gif");
etoiles[i].setStylePrimaryName("x-view-notation-bar");
this.add(etoiles[i]);
}
}
 
/**
* Affiche la note d'une image sous la forme d'étoiles
*/
public void afficherNote() {
// si l'image est notée
if (estNote) {
// on affiche autant d'étoiles que le chiffre de la note
for (int i = 0; i <= noteEnCours; i++) {
etoiles[i].setUrl("note-on.gif");
}
// et si elle est inférieure à la note maximale, on remplit le reste
// par des étoiles vides
for (int j = noteEnCours + 1; j < noteMax; j++) {
etoiles[j].setUrl("note-off.gif");
}
}
// sinon
else {
// on remplit toute la barre avec des étoiles vides
for (int i = 0; i < noteMax; i++) {
etoiles[i].setUrl("note-off.gif");
}
}
 
}
 
/**
* Accesseur pour la note en cours sous forme de string
*
* @return la note en cours sous forme d'une chaine de charactères
*/
public String getNote() {
return "" + noteEnCours;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/MenuImageVue.java
New file
0,0 → 1,190
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
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.MenuItem;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
public class MenuImageVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour l'upload
*/
private MenuItem uploaderImage = null;
/**
* Item pour la suppression
*/
private Item supprimerImage = null;
 
/**
* Item pour l'ajout d'images à la selection
*/
private Item ajouterImageSelection = null;
 
/**
* Item pour vider la selection d'images
*/
private Item viderSelection = null;
 
/**
* Item pour lier la selection d'images
*/
private Item afficherSelection = null;
private Item uploadMultiple = null ;
private Item uploadSimple = null ;
private Item gestionMotsCles = null;
private Menu mn = null ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuImageVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuImageVue(ImageMediateur im) {
super();
 
iMediateur = im;
mn = new Menu();
uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois");
uploadSimple = new Item("Un fichier à la la fois");
mn.addItem(uploadMultiple);
mn.addItem(uploadSimple);
 
// on construit le menu
uploaderImage = new MenuItem("Ajouter des images", mn);
supprimerImage = new Item("Supprimer les images selectionnées");
gestionMotsCles = new Item("Gérer les mots clés");
ajouterImageSelection = new Item(
"Ajouter les images sélectionnées au tampon");
viderSelection = new Item("Vider le tampon");
afficherSelection = new Item("Afficher le tampon");
addItem(uploaderImage);
addItem(supprimerImage);
addItem(gestionMotsCles);
addSeparator() ;
addItem(ajouterImageSelection);
addItem(viderSelection);
addItem(afficherSelection);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
// si c'est la suppression
if (item.equals(supprimerImage)) {
// on notifie le médiateur
getIMediateur().supprimerImages();
}
 
// si c'est l'ajout à la sélection
if (item.equals(ajouterImageSelection)) {
getIMediateur().ajouterImagesSelection();
}
 
// si c'est le vidage de la sélection
if (item.equals(viderSelection)) {
getIMediateur().viderSelection();
}
 
// si c'est l'affichage de la selection
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
// si c'est l'affichage de la selection
if (item.equals(gestionMotsCles)) {
getIMediateur().afficherFenetreGestionMotsCles();
}
// enfin, on cache le menu
hide();
 
}
@Override
public void onShow(Menu menu) {
if(getIMediateur().getCompteSelection() != 0) {
afficherSelection.enable();
viderSelection.enable();
}
else {
afficherSelection.disable();
viderSelection.disable();
}
}
 
});
mn.addListener(new MenuListenerAdapter() {
@Override
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'upload
if (item.equals(uploadMultiple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(true);
}
// si c'est l'upload
if (item.equals(uploadSimple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(false);
}
}
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/ZoomImageVue.java
New file
0,0 → 1,608
package org.tela_botanica.client.vues.image;
 
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.LoadEvent;
import com.google.gwt.event.dom.client.LoadHandler;
import com.google.gwt.event.dom.client.MouseWheelEvent;
import com.google.gwt.event.dom.client.MouseWheelHandler;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.ui.Image;
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.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
 
/**
* Panneau d'affichage d'une image avec des boutons précdents et suivant
*
* @author aurelien
*
*/
public class ZoomImageVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Panneau conteneur pour l'image
*/
private Panel imageConteneur = null;
/**
* l'image à afficher
*/
private Image image = new Image("vide.jpg");
/**
* Bouton précédent
*/
private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
/**
* Bouton suivant
*/
private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
 
/**
* Taille originale Y de l'image
*/
private int imageHeight = 0;
 
/**
* Taille originale X de l'image
*/
private int imageWidth = 0;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
 
/**
* Booleen d'initalisation général
*/
private boolean initialise = false;
private Panel infosTaxon = new Panel();
 
/**
* Booleen d'initalisation du conteneur d'image
*/
private boolean conteneurInitialise = false;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour revenir à la vue précédente, utilisez la roulette ou les boutons fléchés pour faire défiler les images </div>") ;
/**.
* boolean de gestion du double clic
*/
private boolean enClic = false;
private ToolbarButton modeZoom = null;
private ToolbarTextItem valeurZoom = new ToolbarTextItem("x 1");
 
protected boolean scroll = false;
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private ZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer à la vue
*/
public ZoomImageVue(ImageMediateur im) {
super("Zoom");
setId("x-view-zoom-panel");
// on associe le médiateur
iMediateur = im;
 
prev.setStylePrimaryName("x-view-zoom-button-p");
suiv.setStylePrimaryName("x-view-zoom-button-s");
 
// on crée une image qui gère le double clic et la roulette de la souris
image = new Image();
this.setHeader(false);
 
imageConteneur = new Panel();
imageConteneur.setBorder(false);
 
imageConteneur.add(image);
imageConteneur.setId("x-view-zoom-img");
 
// l'image de base est vide
image.setUrl("vide.jpg");
 
this.setLayout(new BorderLayout());
 
prev.setWidth("60px");
suiv.setWidth("60px");
 
modeZoom = new ToolbarButton("Mode Zoom");
Toolbar tb = new Toolbar();
tb.addButton(modeZoom);
tb.addItem(valeurZoom);
//setTopToolbar(tb);
infosTaxon = new Panel();
infosTaxon.setHeader(false);
//infosTaxon.setBorder(false);
infosTaxon.setHeight("30px");
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
this.add(infosTaxon, new BorderLayoutData(RegionPosition.SOUTH));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
configDragAndDrop() ;
 
// on ajoute les listeners
ajouterListeners();
tp.setDismissDelay(1050);
tp.applyTo(image.getElement()) ;
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen qui dit si on doit répnadre l'évènement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
//niveauZoom = 1;
// si on reçoit une string
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise) {
String[] infos = (String[]) nouvelleDonnees;
// c'est l'url de l'image qu'on associe à la vue
if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
getImage().setUrl(infos[0]);
int x = Integer.parseInt(infos[1]);
int y = Integer.parseInt(infos[2]);
 
setTailleImage(x, y);
setIdImage(infos[3]) ;
String infosTaxon = "" ;
if(infos.length == 5 && infos[4] != null) {
infosTaxon = infos[4];
}
setInfosTaxon(infosTaxon);
verifierEtRetaillerImage();
}
}
}
 
/**
* Desactive visuellement le panneau et les boutons
*/
public void desactiverPanneau() {
getImage().setUrl("vide.jpg");
prev.setEnabled(false);
suiv.setEnabled(false);
}
 
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau() {
prev.setEnabled(true);
suiv.setEnabled(true);
}
public void masquerChargement() {
ExtElement imgEl = Ext.get(imageConteneur.getElement());
if(imgEl != null) {
imgEl.mask("Chargement");
}
}
public void demasquerChargement() {
ExtElement imgEl = Ext.get(imageConteneur.getElement());
if(imgEl != null) {
imgEl.unmask();
}
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
image.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
if(!scroll) {
if(enClic) {
getIMediateur().doubleClicZoomImage();
} else {
Timer t = new Timer() {
@Override
public void run() {
enClic = false;
}
};
enClic = true;
t.schedule(800);
}
}
}
});
image.addLoadHandler(new LoadHandler() {
@Override
public void onLoad(LoadEvent event) {
 
verifierEtRetaillerImage();
Ext.get(image.getElement()).center(imageConteneur.getElement());
demasquerChargement();
}
});
image.addMouseWheelHandler(new MouseWheelHandler() {
@Override
public void onMouseWheel(MouseWheelEvent event) {
if(event.isNorth()) {
masquerChargement();
getIMediateur().clicBoutonZoomImage("suiv");
} else {
masquerChargement();
getIMediateur().clicBoutonZoomImage("prev");
}
}
});
// gestion du clic sur le bouton précedent
prev.addClickHandler(new ClickHandler() {
 
// en cas de clic
@Override
public void onClick(ClickEvent event) {
// on notifie le médiateur
masquerChargement();
getIMediateur().clicBoutonZoomImage("prev");
}
});
 
// gestion du clic sur le bouton suivant
suiv.addClickHandler(new ClickHandler() {
 
// en cas de clic
@Override
public void onClick(ClickEvent event) {
// on notifie le médiateur
masquerChargement();
getIMediateur().clicBoutonZoomImage("suiv");
}
 
});
 
// gestion du redimensionnement
this.addListener(new PanelListenerAdapter() {
 
// lors d'un redimensionnement de l'application
 
@Override
public void onBodyResize(Panel panel, java.lang.String width,
java.lang.String height) {
// on vérifie et on retaille l'image
verifierEtRetaillerImage();
}
});
 
// gestion du redimensionnement lors de l'affichage du conteneur
imageConteneur.addListener(new PanelListenerAdapter() {
 
// avant de finir d'afficher
 
@Override
public void onAfterLayout(Container self) {
// on redimensionne
verifierEtRetaillerImage();
}
});
}
 
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
// on modifie enfin la taille de l'image pour qu'elle soit affichée
int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());
int[] tailleImage = new int[2];
if(Ext.isIE()) {
image.setHeight(calculerDimensions(getTailleImage(),max,max)[1]+"px");
image.setWidth(calculerDimensions(getTailleImage(),max,max)[0]+"px");
} else {
if(max == imageConteneur.getHeight()) {
tailleImage[0] = getTailleImage()[0];
tailleImage[1] = max;
image.setHeight(max+"px");
} else {
tailleImage[1] = getTailleImage()[0];
tailleImage[0] = max;
image.setWidth(max+"px");
}
}
}
public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
return res;
}
public void configDragAndDrop()
{
 
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
@Override
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si on reçoit des données provenant d'une grille
if(data instanceof GridDragData)
{
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
return false ;
}
@Override
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur au conteneur de l'image
*
* @return le conteneur de l'image
*/
public Image getImage() {
return image;
}
/**
* Acesseurs pour l'identifiant de l'image
* @return l'id de l'image
*/
public String getIdImage()
{
return idImage ;
}
 
/**
* Accesseur pour le bouton précédent
*
* @return le bouton précédent
*/
public com.google.gwt.user.client.ui.Button getPrev() {
return prev;
}
 
/**
* Accesseur pour le bouton suivant
*
* @return le bouton suivant
*/
public com.google.gwt.user.client.ui.Button getSuiv() {
return suiv;
}
 
/**
* Setter pour la taille de l'image
*
* @param x
* la largeur en pixels
* @param y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y) {
imageHeight = y;
imageWidth = x;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
idImage = id ;
}
public void setInfosTaxon(String nomTaxon) {
if(nomTaxon != null && !nomTaxon.equals("")) {
nomTaxon = getNomsObservationsFormatees(nomTaxon);
}
infosTaxon.setHtml("<div id='infos_taxon'><span class='texte_info_taxon'>"+nomTaxon+"</span></div>");
infosTaxon.doLayout();
}
 
/**
* renvoie la taille originale de l'image
*
* @return un tableau de deux entiers contenant la largeur puis la hauteur
*/
public int[] getTailleImage() {
int[] taille = { imageHeight, imageWidth };
 
return taille;
}
public boolean estPortrait() {
return imageHeight > imageWidth;
}
public boolean estPaysage() {
return !estPortrait();
}
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
 
return imageConteneur;
 
}
private String getNomsObservationsFormatees(String nomObs) {
String htmlInfobulle = "";
String[][] obs = getObservationsAssociees(nomObs);
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) {
htmlInfobulle += ", "+obs[i][1];
}
}
htmlInfobulle = htmlInfobulle.replaceFirst(", ", "");
return htmlInfobulle;
}
private String[][] getObservationsAssociees(String nomObs) {
if(nomObs.trim().equals("")) {
return new String[0][0];
}
String[] obsTab = nomObs.split(";;");
String[][] obsAnalysees = new String[obsTab.length][3];
for(int i = 0; i < obsTab.length; i++) {
obsAnalysees[i] = obsTab[i].split("#");
}
return obsAnalysees;
}
private boolean[] estAssocieeTransmise(String nomObs) {
String[][] obs = getObservationsAssociees(nomObs);
boolean[] associeesTranmises = {false, false};
if(obs.length > 0) {
associeesTranmises[0] = true;
}
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) {
associeesTranmises[1] = true;
}
}
return associeesTranmises;
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/filtres/RechercheFiltreTaxonVue.java
New file
0,0 → 1,118
package org.tela_botanica.client.vues.image.filtres;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
 
public class RechercheFiltreTaxonVue extends Panel implements Filtrable {
 
private ImageMediateur iMediateur = null;
private TextField champRecherche = null;
private static String titrePanneau = "Recherche libre";
private String valeurRecherchee= "";
private Button boutonRechercher = null;
private boolean estModifie = true;
private final int KEY_ENTER = 13;
public RechercheFiltreTaxonVue(ImageMediateur im) {
super(titrePanneau);
iMediateur = im;
champRecherche = new TextField();
champRecherche.setWidth("90%");
boutonRechercher = new Button("Rechercher");
boutonRechercher.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
valider();
}
});
champRecherche.addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ENTER:
valider();
break;
}
}
});
add(champRecherche);
add(boutonRechercher);
setCollapsible(true);
setTitleCollapse(true);
setPaddings(5);
}
 
 
@Override
public boolean renvoyerEtatFiltre() {
return estModifie;
}
 
 
@Override
public String renvoyerNomFiltre() {
return "Recherche Libre";
}
 
@Override
public String[] renvoyerValeursAFiltrer() {
String nom = "recherche";
if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) {
valeurRecherchee = champRecherche.getValueAsString();
nom = "recherche";
} else {
nom = "recherche";
valeurRecherchee = "";
}
String[] valeurs = {nom,valeurRecherchee};
return valeurs;
}
 
 
@Override
public void valider() {
if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) {
estModifie = true;
iMediateur.obtenirNombreMiniListeObservations();
} else {
estModifie = false;
}
}
public void raz() {
if(champRecherche.isCreated()) {
champRecherche.reset();
valeurRecherchee = "";
}
}
 
@Override
public void viderFiltre() {
champRecherche.setValue("");
valeurRecherchee = "";
}
}
 
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/filtres/PanneauFiltresImagesVues.java
New file
0,0 → 1,208
package org.tela_botanica.client.vues.image.filtres;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue;
import com.gwtext.client.core.Ext;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
 
/**
* Panneau contenant les filtres qu'on peut appliquer aux images
*
* @author aurelien
*
*/
public class PanneauFiltresImagesVues extends Panel {
 
/**
* Le médiateur associé
*/
private ImageMediateur iMediateur = null;
 
/**
* L'arbre pour la recherche par mots clés
*/
private ArbreMotsClesFiltreVue motsClesFiltres = null;
/**
* L'arbre pour la recherche par mots clés
*/
private ArbreDateImageFiltreVue arbreDateImageFiltreVue = null;
/**
* La barre de recherche libre
*/
private BarreRechercheFiltreVue rechercheLibreFiltreVue = null;
 
/**
* Recherche par contenu du tampon
*/
private SelectionFiltreVue selectionFiltreVue = null;
 
/**
* Bouton de validation
*/
private Button valider = null;
 
/**
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
*/
@SuppressWarnings("unused")
private PanneauFiltresImagesVues() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer
*/
public PanneauFiltresImagesVues(ImageMediateur im) {
super("Filtres");
iMediateur = im;
this.setCollapsible(true);
setLayout(new RowLayout());
 
rechercheLibreFiltreVue = new BarreRechercheFiltreVue(im);
rechercheLibreFiltreVue.setTitle("Recherche libre");
rechercheLibreFiltreVue.setCollapsible(true);
add(rechercheLibreFiltreVue, new RowLayoutData());
if(Ext.isIE()) {
add(rechercheLibreFiltreVue);
rechercheLibreFiltreVue.setHeight(110);
} else {
add(rechercheLibreFiltreVue,new RowLayoutData(100));
}
 
arbreDateImageFiltreVue = new ArbreDateImageFiltreVue(im) ;
arbreDateImageFiltreVue.setWidth("100%") ;
arbreDateImageFiltreVue.setBorder(false);
add(arbreDateImageFiltreVue, new RowLayoutData());
 
motsClesFiltres = new ArbreMotsClesFiltreVue(im);
motsClesFiltres.setTitle("Mots clés");
motsClesFiltres.setAutoScroll(true);
add(motsClesFiltres, new RowLayoutData());
 
selectionFiltreVue = new SelectionFiltreVue(im);
addListener(new ContainerListenerAdapter() {
 
@Override
public void onRender(Component component) {
// TODO Auto-generated method stub
 
rechercheLibreFiltreVue.ajouterListeners();
arbreDateImageFiltreVue.ajouterListeners();
}
});
}
 
/**
* Accesseur pour le filtre des mots clés
*
* @return le filtre des mots clés
*/
public ArbreMotsClesFiltreVue getMotsClesFiltre() {
return motsClesFiltres;
}
 
/**
* Accesseur pour le filtre général
*
* @return le filtre général
*/
public BarreRechercheFiltreVue getBarreRecherche() {
return rechercheLibreFiltreVue;
}
/**
* Accesseur pour le filtre des dates
*
* @return le filtre des dates
*/
public ArbreDateImageFiltreVue getArbreDateRecherche() {
return arbreDateImageFiltreVue;
}
 
/**
* Renvoie un booléen indiquant si un des filtres a été modifié
*
* @return true sur un des filtres est modifié, false sinon
*/
public boolean renvoyerEtatFiltre() {
 
return (motsClesFiltres.renvoyerEtatFiltre()
|| rechercheLibreFiltreVue.renvoyerEtatFiltre()
|| arbreDateImageFiltreVue.renvoyerEtatFiltre()
|| selectionFiltreVue.renvoyerEtatFiltre());
}
 
/**
* Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre",
* "valeur"
*
* @return un tableau contenant les noms et les valeurs à filtrer
*/
public String[][] renvoyerValeursAFiltrer() {
String[] filtresDates = arbreDateImageFiltreVue.renvoyerValeursAFiltrer();
int lgSup = 0;
if(filtresDates.length > 0) {
String[] nomFiltresDates = filtresDates[0].split(",");
String[] valFiltresDates = filtresDates[1].split(",");
lgSup = Math.max(nomFiltresDates.length, valFiltresDates.length);
}
String[][] filtres = new String[3 + lgSup][2];
for(int i=3; i < filtres.length; i++) {
filtres[i][0] = filtresDates[0].split(",")[i - 3];
filtres[i][1] = filtresDates[1].split(",")[i -3];
}
filtres[0] = motsClesFiltres.renvoyerValeursAFiltrer();
filtres[1] = rechercheLibreFiltreVue.renvoyerValeursAFiltrer();
filtres[2] = selectionFiltreVue.renvoyerValeursAFiltrer();
return filtres;
}
 
public void viderFiltres() {
motsClesFiltres.viderFiltre();
rechercheLibreFiltreVue.viderFiltre();
arbreDateImageFiltreVue.viderFiltre();
selectionFiltreVue.viderFiltre();
}
 
public void viderFiltre(String nom) {
if(nom.equals("id_mots_cles")) {
motsClesFiltres.viderFiltre();
}
if(nom.equals("recherche")) {
rechercheLibreFiltreVue.viderFiltre();
}
if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) {
arbreDateImageFiltreVue.viderFiltre(nom);
}
if(nom.equals("ci_id_tampon")) {
selectionFiltreVue.viderFiltre();
}
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/filtres/BarreRechercheFiltreVue.java
New file
0,0 → 1,191
package org.tela_botanica.client.vues.image.filtres;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.HorizontalLayout;
 
/**
* Fenêtre de recherche pour les mots clés, contenant un champ texte, et un
* bouton cliquable
*
* @author aurelien
*
*/
public class BarreRechercheFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Barre de recherche
*
*/
private TextField champRecherche = null;
 
/**
* Booleen d'etat du filtre
*/
private boolean filtreModifie = false;
private Button boutonRechercher = null;
 
/**
* mot(s) à chercher
*/
private String motsAChercher = "";
private final int KEY_ENTER = 13;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreRechercheFiltreVue() {
super();
}
 
/**
* Constructeur avec médiateur
*
* @param im
*/
public BarreRechercheFiltreVue(ImageMediateur im) {
super();
setLayout(new HorizontalLayout(3));
iMediateur = im;
 
champRecherche = new TextField();
boutonRechercher = new Button("OK");
 
add(champRecherche);
add(boutonRechercher);
 
setPaddings(5);
setBorder(false);
setAutoWidth(true);
setCollapsible(true);
ajouterListeners();
}
 
/**
* ajoute des listeners
*/
public void ajouterListeners() {
boutonRechercher.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
valider();
iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage());
}
});
champRecherche.addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ENTER:
valider();
iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage());
break;
}
}
});
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
filtreModifie = false;
 
}
 
/**
* renvoie l'état du filtre (modifié ou non)
*
* @return l'état du filtre
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
/**
* Renvoie le nom du filtre
*
* @return le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "Recherche ";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
 
valider() ;
String[] valeurFiltre = { "recherche", motsAChercher };
return valeurFiltre;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Effectue quelque opérations dans la classe et envoie une requête de
* données au médiateur
*/
@Override
public void valider() {
filtreModifie = true;
motsAChercher = champRecherche.getText();
}
 
/**
* Affiche la fenetre
*/
public void afficherFiltre() {
 
champRecherche.setValue(motsAChercher);
}
 
@Override
public void viderFiltre() {
champRecherche.setValue("");
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/filtres/SelectionFiltreVue.java
New file
0,0 → 1,98
package org.tela_botanica.client.vues.image.filtres;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.form.Checkbox;
 
public class SelectionFiltreVue extends Panel implements Filtrable {
 
private ImageMediateur iMediateur = null;
 
private boolean filtreModifie = false;
 
private Checkbox check = null;
@SuppressWarnings("unused")
private SelectionFiltreVue()
{
super() ;
}
 
public SelectionFiltreVue(ImageMediateur im) {
 
super();
iMediateur = im ;
Label labelRecherche = new Label(
"Afficher uniquement les images dans le tampon :");
add(labelRecherche);
setBorder(false);
setPaddings(5);
 
/*
* combo = new ComboBox() ; String tout = "toutes les images "; String
* selection = "dans le tampon seulement" ; Object[][] data = new
* Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ;
* data[1][1] = selection ;
* // creation du store qui les contient FieldDef defIdChoix = new
* IntegerFieldDef("id_choix"); FieldDef defNomChoix = new
* StringFieldDef("nom_choix");
*
* FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new
* RecordDef(defTab) ;
*
* final MemoryProxy dataProxy = new MemoryProxy(data); final
* ArrayReader reader = new ArrayReader(rd);
*
* st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ;
* combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL);
* combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ;
* add(combo) ;
*/
 
check = new Checkbox();
check.setChecked(false) ;
add(check);
 
}
 
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
@Override
public String renvoyerNomFiltre() {
 
return "Filtre par tampon";
}
 
@Override
public String[] renvoyerValeursAFiltrer() {
 
if (check.getValue()) {
String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() };
return val;
}
String[] val = { "ci_id_tampon", "" };
return val;
}
 
@Override
public void valider() {
 
filtreModifie = true;
 
}
 
@Override
public void viderFiltre() {
check.setChecked(false);
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java
New file
0,0 → 1,586
package org.tela_botanica.client.vues.image.filtres;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.DateObservation;
import org.tela_botanica.client.modeles.objets.ListeDate;
import org.tela_botanica.client.util.Util;
 
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
import com.gwtext.client.core.EventObject;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreDateImageFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur imageMediateur = null;
 
/**
* Les localites en cours
*/
private String donneesDateEnCours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreDonneesDates = null;
 
/**
* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
*/
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
private boolean arbreCharge = false ;
 
private String nomFiltre = "" ;
private String prefixeId = "date_image_";
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreDateImageFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreDateImageFiltreVue(ImageMediateur imgMed) {
 
// on crée le panel
super("Dates");
this.imageMediateur = imgMed;
 
arbreDonneesDates = new TreePanel();
 
this.setPaddings(5);
 
this.setCollapsible(true);
this.setAutoScroll(true);
this.setBorder(false);
arbreDonneesDates.setBorder(false);
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
 
// on interdit le drag and drop dans l'arbre
arbreDonneesDates.setEnableDD(false);
arbreDonneesDates.setId("x-view-tree-filter-date-image");
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Dates");
root.addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
 
if(!arbreCharge)
{
obtenirDatesImages();
arbreCharge = true ;
}
}
}) ;
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.setRootVisible(true);
setBorder(false);
root.setExpandable(true) ;
 
add(arbreDonneesDates);
// enfin on considère le composant comme instancié
estInstancie = true;
}
 
/**
* ajoute les listeners pour les boutons et le cochage des entites
*/
public void ajouterListeners() {
arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
@Override
public void onClick(TreeNode node, EventObject e) {
gererClicNoeud(node);
}
}) ;
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
 
if(!arbreCharge)
{
obtenirDatesImages();
arbreCharge = true ;
}
}
}) ;
}
private void gererClicNoeud(TreeNode node) {
mettreAJourValeurEnCours(node);
imageMediateur.obtenirPhotoGalerie() ;
}
private void mettreAJourValeurEnCours(TreeNode node) {
nomFiltre = "" ;
donneesDateEnCours = "" ;
String nomPere = "" ;
String nomGrandPere = "" ;
switch(node.getDepth())
{
case 0:
if(arbreCharge) {
nomFiltre = "";
donneesDateEnCours = "";
}
break;
case 3: nomFiltre += "annee,mois,jour";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 2: nomFiltre += "annee,mois";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 1: nomFiltre += "annee";
donneesDateEnCours += ((String[])node.getUserObject())[1] ;
break;
default:
break;
}
filtreModifie = true ;
}
 
public void initialiser() {
arbreCharge = false ;
donneesDateEnCours = "";
arbreDonneesDates.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
obtenirDatesImages() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if (nouvelleDonnees instanceof ListeDate) {
String annee=null;
String mois=null;
String jour=null;
ListeDate data = (ListeDate) nouvelleDonnees ;
// on crée un arbre vide
TreeNode root = new TreeNode();
root.setId("racine_date");
root.setText("Dates");
String[] usObjRoot = { "Dates", "Dates", prefixeId+"racine_date"};
root.setUserObject(usObjRoot);
Tree nouvelArbre = new Tree();
nouvelArbre.setRootNode(root);
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
DateObservation ent=data.get(it.next());
annee= ent.getAnnee() ;
mois= ent.getMois() ;
String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;
jour= ent.getJour() ;
if(annee.contains("0000")) {
annee="Inconnue" ;
}
if(jour.contains("00")) {
jour="Inconnue" ;
}
Node noeudMemeAnnee = nouvelArbre.getNodeById(prefixeId+annee);
// si la région existe déjà
if(noeudMemeAnnee != null)
{
// on teste si la localité existe
Node noeudMemeMois = nouvelArbre.getNodeById(prefixeId+(annee+mois));
if(noeudMemeMois != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeJour = nouvelArbre.getNodeById(prefixeId+(annee+mois+jour));
if(noeudMemeJour != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_jour = new TreeNode();
node_jour.setId(prefixeId+(annee+mois+jour));
node_jour.setText(jour);
noeudMemeMois.appendChild(node_jour) ;
String[] usObj = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj);
}
}
else
{
TreeNode node_mois = new TreeNode();
node_mois.setId(prefixeId+(annee+mois));
node_mois.setText(moisLettre);
noeudMemeAnnee.appendChild(node_mois) ;
String[] usObj = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj);
TreeNode node_jour = new TreeNode();
node_jour.setId(prefixeId+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj2 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj2);
}
}
else
{
TreeNode node_annee = new TreeNode();
node_annee.setId(prefixeId+annee);
node_annee.setText(annee);
root.appendChild(node_annee) ;
String[] usObj = {annee, annee, annee};
node_annee.setUserObject(usObj);
TreeNode node_mois = new TreeNode();
node_mois.setId(prefixeId+(annee+mois));
node_mois.setText(moisLettre);
node_annee.appendChild(node_mois) ;
String[] usObj2 = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj2);
TreeNode node_jour = new TreeNode();
node_jour.setId(prefixeId+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj3 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj3);
}
 
}
// on trie
root.sort(comparerNoeuds()) ;
// on vide tous les noeuds
arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
@Override
public boolean execute(Node node) {
node.remove();
return true;
}
});
 
// et on recopie le nouvel arbre
copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates
.getRootNode());
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
// l'état du filtre est réinitialisé
filtreModifie = false;
//show() ;
doLayout();
 
}
}
 
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreDonneesDates;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
@Override
public String renvoyerNomFiltre() {
 
return "Dates";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
@Override
public String[] renvoyerValeursAFiltrer() {
 
valider();
String[] valeursFiltrees = new String[0];
if(!nomFiltre.trim().equals("") && !donneesDateEnCours.trim().equals("")) {
valeursFiltrees = new String[2];
valeursFiltrees[0] = nomFiltre;
valeursFiltrees[1] = donneesDateEnCours;
}
 
return valeursFiltrees;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setUserObject(usObj);
child.setId(prefixeId+usObj[2]);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
@Override
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
@Override
public void valider() {
if (estInstancie) {
}
}
public Comparator<TreeNode> comparerNoeuds()
{
return new Comparator<TreeNode>() {
 
@Override
public int compare(TreeNode o1, TreeNode o2) {
String n1 = ((String[])o1.getUserObject())[1] ;
String n2 = ((String[])o2.getUserObject())[1] ;
return n1.compareTo(n2) ;
}
} ;
}
public void raz() {
arbreCharge = false ;
arbreDonneesDates.collapseAll();
arbreDonneesDates.clear();
TreeNode root = new TreeNode("Dates");
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
@Override
public void onExpand(Node node) {
if(!arbreCharge)
{
obtenirDatesImages() ;
arbreCharge = true ;
}
}
}) ;
this.doLayout() ;
donneesDateEnCours = "";
}
public void obtenirDatesImages() {
imageMediateur.obtenirDatesImages(this);
}
 
@Override
public void viderFiltre() {
donneesDateEnCours = "";
arbreDonneesDates.getSelectionModel().clearSelections();
}
 
public void viderFiltre(String nom) {
final int profondeur = calculerProfondeurPourNomFiltre(nom);
// on vide tous les noeuds
arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() {
 
@Override
public boolean execute(Node node) {
boolean continuer = true;
TreeNode noeudArbreEncours = (TreeNode)node;
if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) {
int profondeurDepart = noeudArbreEncours.getDepth();
for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {
noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();
}
arbreDonneesDates.getSelectionModel().select(noeudArbreEncours);
mettreAJourValeurEnCours(noeudArbreEncours);
continuer = false;
}
return continuer;
}
 
});
}
private int calculerProfondeurPourNomFiltre(String nom) {
int profondeur = 0;
if(nom.equals("annee")) {
profondeur = 1;
}
if(nom.equals("mois")) {
profondeur = 2;
}
if(nom.equals("jour")) {
profondeur = 3;
}
return profondeur;
}
 
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java
New file
0,0 → 1,654
package org.tela_botanica.client.vues.image;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.MiniBarrePaginationVue;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.RowSelectionModel;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
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.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.dd.DragData;
 
/**
* liste d'observation pour l'association d'images aux observations
* @author aurelien
*
*/
public class MiniListeObservationVue extends GridPanel implements Rafraichissable, ListePaginable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null ;
/**
* Booléen d'instanciation
*/
private boolean estInstancie = false ;
/**
* Le modèle de colonnes
*/
private ColumnModel colModel = null ;
private SimpleStore store = null ;
private MiniBarrePaginationVue pgBar = new MiniBarrePaginationVue(this) ;
private Toolbar bt = new Toolbar() ;
/**
* Combobox permettant de selectionner le mode
* modification ou bien création
*/
private ComboBox selecteurMode = new ComboBox();
Store storeMode = null ;
 
private boolean liaison;
int pageEnCours = 0;
int nbElements = 0;
int taillePage = 50;
private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION";
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Constructeur avec arguments
* @param im le médiateur à associer à la vue
*/
public MiniListeObservationVue(ImageMediateur im)
{
iMediateur = im ;
this.setId("x-view-mini-obs") ;
// on construit le modèle de colonnes
 
// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir)
Renderer colRend = new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
return "" ;
}
return value.toString() ;
}
} ;
Renderer dateRend = new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
return "" ;
}
else
{
String dateEntiere = value.toString() ;
String[] dateEtHeure = dateEntiere.split(" ", 2);
if(verifierFormatDate(dateEtHeure[0])) {
String[] dateFormateeTab = dateEtHeure[0].split("-",3);
return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;
}
}
return value.toString() ;
}
} ;
// on crée un store simple contenant un petit set de données et deux colonnes
store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, getObs());
ColumnConfig[] columns = {
new ColumnConfig("", "transmis", 30, true, new Renderer() {
 
@Override
public String render(Object value, CellMetadata cellMetadata,
Record record, int rowIndex, int colNum, Store store) {
if(value.equals("1"))
{
return "<img src=\"tela.png\"/></img>" ;
}
else
{
return "" ;
}
}
}),
new ColumnConfig("Taxon", "plante", 145, true, colRend),
new ColumnConfig("Date", "date", 68, true, dateRend),
new ColumnConfig("Lieu", "lieu", 145, true, colRend),
new ColumnConfig("Numero", "ordre_obs", 50, true, colRend), } ;
ColumnModel columnModel = new ColumnModel(columns);
colModel = columnModel ;
 
setTitle("Observations");
// on associe le modèle de colonnes
setColumnModel(columnModel);
setAutoScroll(true) ;
setHeight("100%") ;
setAutoWidth(true) ;
// on autorise le drag 'n drop pour un certain groupe
this.setEnableDragDrop(true);
this.setDdGroup("DragGroupName");
store.load();
setStore(store) ;
setBottomToolbar(pgBar) ;
Object[][] mode = {{"toutes les observations",false} , {"observation liée", true} };
storeMode = new SimpleStore(new String[] { "nom_mode", "mode" },
mode);
storeMode.load();
selecteurMode.setStore(storeMode);
selecteurMode.setDisplayField("nom_mode") ;
selecteurMode.setLabel("mode ") ;
selecteurMode.setForceSelection(true) ;
selecteurMode.setValue("toutes les observations") ;
selecteurMode.setEditable(false) ;
selecteurMode.setCls("x-selec-consult") ;
bt = new Toolbar() ;
bt.addField(selecteurMode) ;
//this.setAutoExpandColumn("plante");
setTopToolbar(bt) ;
selecteurMode.addListener(new ComboBoxListenerAdapter() {
 
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
// et on met la valeur à jour dans la combobox
comboBox.setValue(record.getAsString("nom_mode"));
setModification(record.getAsString("mode")) ;
}
 
});
setAutoScroll(true) ;
// on configure le drag 'n drop
configDragAndDrop() ;
this.addGridListener(new GridListenerAdapter() {
 
@Override
public void onContextMenu(EventObject e) {
// si pas de selection, on selection au moins la ligne sur laquelle on a fait le clic
if(getSelectionModel().getSelections().length <= 0) {
int index = getView().findRowIndex(e);
Record rddrop = getStore().getRecordAt(index) ;
getSelectionModel().selectRecords(rddrop);
}
e.stopEvent() ;
MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ;
mlv.showAt(e.getXY()) ;
}
}) ;
// TODO: voir s'il existe un autre moyen de désactiver la multiselection
// ça semble bien compliqué de faire comme ça
getSelectionModel().addListener(new RowSelectionListenerAdapter() {
@Override
public boolean doBeforeRowSelect(RowSelectionModel sm, int rowIndex,
boolean keepExisting, Record record) {
sm.clearSelections();
return true;
}
});
obtenirNombreMiniListeObservations();
}
/**
* Configure le drag 'n drop pour la liste
*/
private void configDragAndDrop()
{
// on choisit le texte qui sera affiché lors d'un drag 'n drop
setDragDropText("Faites glisser l'observation sur une image ou une selection d'images pour les lier") ;
//On active le drag 'n drop
this.setEnableDragDrop(true);
 
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
this.setDdGroup("DragGroupName");
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
@Override
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si on reçoit des données provenant d'une grille
if(data instanceof GridDragData)
{
// on la convertit
GridDragData gdd = (GridDragData)data ;
// et on vérifie que les données ne viennent pas de l'élément courant
if(gdd.getGrid().getId().equals("x-view-mini-obs"))
{
return false ;
}
else
{
// on appelle le médiateur
return iMediateur.lierImagesDD(source, e, data) ;
}
}
return false ;
}
@Override
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof ListeObservation)
{
if(this.getView() != null)
{
ListeObservation data = (ListeObservation)nouvelleDonnees ;
String[][] listeObs = new String[data.size()][6] ;
int i = 0 ;
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=data.get(it.next());
listeObs[i][0] = obs.getTransmis();
listeObs[i][1] = obs.getNomSaisi();
listeObs[i][2] = obs.getDate() ;
listeObs[i][3] = Util.formaterLieu(obs, modeleLieu);
listeObs[i][4] = obs.getNumeroOrdre();
listeObs[i][5] = obs.getId();
i++ ;
}
store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, listeObs);
store.load();
this.reconfigure(store, colModel) ;
}
else
{
addListener(new ContainerListenerAdapter() {
@Override
public void onShow(Component c)
{
obtenirNombreMiniListeObservations() ;
}
@Override
public void onAfterLayout(Container c)
{
obtenirNombreMiniListeObservations() ;
}
}) ;
}
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'observation 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
changerPageMaxEtCourante(pageMax,pageEnCours,taillePage,nbElements) ;
masquerChargement();
obtenirMiniListeObservations();
}
redimensionner();
deMasquerChargement() ;
}
private void obtenirMiniListeObservations()
{
iMediateur.obtenirMiniListeObservations(this, taillePage, pageEnCours) ;
}
private void obtenirNombreMiniListeObservations()
{
iMediateur.obtenirNombreMiniListeObservations(this) ;
}
/**
* Renvoie le faux set de données pour le store
* @return un tableau à deux colonnes int - String
*/
private Object[][] getObs() {
return new Object[][]{
} ;
}
@Override
public Store getStore()
{
return store ;
}
public MiniBarrePaginationVue getBarrePagination()
{
return pgBar ;
}
private void setModification(String mode)
{
if(mode.equals("true")) {
 
liaison = true ;
selecteurMode.removeClass("x-selec-consult") ;
selecteurMode.setCls("x-selec-liaison") ;
getBarrePagination().disable();
doLayout();
}
else
{
liaison = false ;
selecteurMode.removeClass("x-selec-liaison") ;
selecteurMode.setCls("x-selec-consult") ;
getBarrePagination().enable();
doLayout();
}
store.removeAll() ;
iMediateur.changerModeLiaison(liaison) ;
}
public boolean getMode() {
return liaison ;
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
if (masked!=null) {
masked.mask("Chargement") ;
}
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void deMasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
if (masked!=null) {
masked.unmask() ;
}
}
public String getIdSelectionnees() {
Record[] sels = getSelectionModel().getSelections() ;
String id = "";
for(int i = 0; i < sels.length; i++) {
id += ","+sels[i].getAsString("id_obs") ;
}
id = id.replaceFirst(",", "");
return id ;
}
public void supprimerLiaison() {
Record[] rdObs = getSelectionModel().getSelections() ;
for(int i = 0 ; i < rdObs.length ; i++) {
getStore().remove(rdObs[i]) ;
this.getView().refresh() ;
}
}
public void redimensionner() {
if(getView() != null) {
int taille = 400;
if(Window.getClientHeight() > 800 ) {
taille = Window.getClientHeight() - 350;
}
setHeight(taille);
getView().setForceFit(true);
doLayout();
}
else {
 
}
}
/**
* Montre le menu de liaison aux coordonnées indiquées
* @param e
*/
public void montrerContextMenuLiaison(EventObject e) {
final Menu liObs = new Menu();
final Item lierObservation = new Item("Lier aux images selectionnées");
liObs.addItem(lierObservation);
liObs.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
@Override
public void onItemClick(BaseItem item, EventObject ev) {
 
// si c'est la suppression
if (item.equals(lierObservation)) {
// on notifie le médiateur
 
}
// enfin, on cache le menu
liObs.hide();
 
}
 
});
liObs.showAt(e.getXY());
}
 
@Override
public void changerNumeroPage(int pageCourante) {
pageEnCours = pageCourante ;
masquerChargement();
 
// On lance le chargerment des observations
iMediateur.obtenirNombreMiniListeObservations(this);
}
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
@Override
public void changerTaillePage(int nouvelleTaillePage)
{
taillePage = nouvelleTaillePage ;
pageEnCours = calculerPageCourante(nbElements) ;
 
masquerChargement();
 
// On lance le chargerment des observations
iMediateur.obtenirNombreMiniListeObservations(this);
// et on met à jour la taille de page dans les barres d'outils
pgBar.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} ;
pgBar.rafraichir(pages, false) ;
}
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
*/
public int calculerNbPages(int nbElements)
{
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return nPageInt.intValue() ;
}
 
/**
* Recalcule la page en cours lors du changement du nombre d'élements
* @param nbElements le nombre d'élements total
* @return la nouvelle page encours
*/
public int calculerPageCourante(int nbElements)
{
// on calcule le nombre de page
int nouvelNbPages = calculerNbPages(nbElements) ;
// la nouvelle page en cours
double nPageCourante = (1.0*pageEnCours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return Math.abs(nPageInt.intValue()) ;
}
public boolean verifierFormatDate(String date) {
String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
if(date.matches(regex) && !date.equals("0000-00-00")) {
return true ;
}
else {
return false;
}
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/PanneauMetadonneesVue.java
New file
0,0 → 1,526
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.vues.image.ImageMotsClesVue;
import org.tela_botanica.client.vues.image.filtres.RechercheFiltreTaxonVue;
 
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.NameValuePair;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.form.DateField;
import com.gwtext.client.widgets.form.TextArea;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.GridView;
import com.gwtext.client.widgets.grid.PropertyGridPanel;
import com.gwtext.client.widgets.grid.event.GridCellListenerAdapter;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.layout.VerticalLayout;
 
/**
* Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il
* implémente l'interface rafraichissable
*
* @author aurelien
*
*/
public class PanneauMetadonneesVue extends TabPanel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur imediateur = null;
/**
* Le panneau des Exifs
*/
private PropertyGridPanel ExifGrid = null;
/**
* Le panneau des Iptc
*/
private PropertyGridPanel IptcGrid = null;
 
/**
* La grille pour le panneau des Exifs
*/
private GridView gViewExif = null;
/**
* La grille pour le panneau de Iptc
*/
private GridView gViewIptc = null;
 
/**
* L'onglet des Exifs
*/
private Panel panneauExifGrid = null;
/**
* L'onglet des Iptc
*/
private Panel panneauIptcGrid = null;
/**
* L'onglet des infos
*/
private Panel panneauInfoGrid = null;
/**
* L'onglet des mots clés
*/
private ImageMotsClesVue panneauMotsCles = null;
/**
* l'onglet des observations
*/
private Panel panneauMiniListeObservation = null;
 
/**
* Le champ commentaire
*/
private TextField commentaireGeneral = null;
/**
* Le champ date
*/
private DateField dateImage = null;
/**
* La barre de recherche rapide des taxons
*/
private RechercheFiltreTaxonVue rechercheFiltreTaxonVue = null;
/**
* La mini liste des observations
*/
private MiniListeObservationVue miniListeObservation = null ;
/**
* Le bouton de validation
*/
Button validerInfo = null;
 
/**
* Barre de notation
*/
BarreNotationVue noteVue = null;
 
/**
* Booleen d'instanciation
*/
boolean estInstancie = false;
Timer timerRedimensionnement = null;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private PanneauMetadonneesVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
*/
public PanneauMetadonneesVue(ImageMediateur im) {
super();
 
// on associe le médiateur
imediateur = im;
 
// on crée et dispose les panneaux et les champs
panneauExifGrid = new Panel("Exif");
panneauIptcGrid = new Panel("Iptc");
panneauInfoGrid = new Panel("Infos");
panneauMotsCles = new ImageMotsClesVue(im);
panneauMotsCles.setHeight("50%");
 
Panel sousPanneauInfosGenerales = new Panel("Infos Générales");
sousPanneauInfosGenerales.setLayout(new VerticalLayout());
sousPanneauInfosGenerales.setBorder(false);
sousPanneauInfosGenerales.setHeight(200);
sousPanneauInfosGenerales.setAutoWidth(true);
sousPanneauInfosGenerales.setMargins(5);
sousPanneauInfosGenerales.setPaddings(5);
sousPanneauInfosGenerales.setCollapsible(true);
 
Label labelComm = new Label("Commentaires :");
labelComm.setHeight("20px");
commentaireGeneral = new TextArea();
commentaireGeneral.setWidth("90%");
Label labelDate = new Label("Date :");
Label labelNote = new Label("Note :");
 
panneauMotsCles.setBorder(false);
 
labelDate.setHeight("20px");
 
dateImage = new DateField();
dateImage.setAutoWidth(true);
dateImage.setFormat("d/m/Y");
 
validerInfo = new Button("OK");
 
noteVue = new BarreNotationVue(im, 5);
panneauMiniListeObservation = new Panel("Observations") ;
if(!Ext.isIE()) {
panneauMiniListeObservation.setLayout(new RowLayout());
}
miniListeObservation = new MiniListeObservationVue(im);
rechercheFiltreTaxonVue = new RechercheFiltreTaxonVue(im);
rechercheFiltreTaxonVue.setTitle("Recherche dans les observations");
if(Ext.isIE()) {
panneauMiniListeObservation.add(rechercheFiltreTaxonVue);
rechercheFiltreTaxonVue.setHeight(90);
} else {
panneauMiniListeObservation.add(rechercheFiltreTaxonVue, new RowLayoutData(90));
}
rechercheFiltreTaxonVue.setWidth("100%") ;
rechercheFiltreTaxonVue.setBorder(false);
if(Ext.isIE()) {
panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData(400)) ;
} else {
panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData()) ;
}
 
sousPanneauInfosGenerales.add(labelComm);
sousPanneauInfosGenerales.add(commentaireGeneral);
sousPanneauInfosGenerales.add(labelDate);
sousPanneauInfosGenerales.add(dateImage);
sousPanneauInfosGenerales.add(labelNote);
sousPanneauInfosGenerales.add(noteVue);
sousPanneauInfosGenerales.add(validerInfo);
sousPanneauInfosGenerales.setAutoHeight(true);
panneauMotsCles.setAutoHeight(true);
 
panneauInfoGrid.setBorder(false);
panneauInfoGrid.setAutoHeight(true);
panneauExifGrid.setAutoScroll(true);
panneauIptcGrid.setAutoScroll(true);
 
panneauInfoGrid.add(sousPanneauInfosGenerales);
panneauInfoGrid.add(panneauMotsCles);
 
this.add(panneauMiniListeObservation) ;
this.add(panneauInfoGrid);
this.add(panneauExifGrid);
this.add(panneauIptcGrid);
 
gViewExif = new GridView();
gViewExif.setForceFit(true);
 
ExifGrid = new PropertyGridPanel();
ExifGrid.setId("meta_exif");
ExifGrid.setView(gViewExif);
ExifGrid.setNameText("Métadonnées Exif");
ExifGrid.setAutoWidth(true);
ExifGrid.setHeight(500);
ExifGrid.setSorted(false);
ExifGrid.setAutoScroll(true);
 
gViewIptc = new GridView();
gViewIptc.setForceFit(true);
 
IptcGrid = new PropertyGridPanel();
IptcGrid.setId("meta_iptc");
IptcGrid.setView(gViewIptc);
 
IptcGrid.setNameText("Métadonnées IPTC");
IptcGrid.setAutoWidth(true);
IptcGrid.setHeight(500);
IptcGrid.setSorted(false);
IptcGrid.setAutoScroll(true);
 
panneauExifGrid.add(ExifGrid);
panneauIptcGrid.add(IptcGrid);
 
// on ajoute les listeners
ajouterListeners();
 
// on effectue le rendu
//this.doLayout(true);
 
}
 
private void ajouterListeners() {
// on ajoute un écouteur
validerInfo.addListener(new ButtonListenerAdapter() {
 
// gestion du clic
 
@Override
public void onClick(Button button, EventObject e) {
 
button.focus();
// lors du clic sur le bouton valider on met à jour les
// commentaires et la date
getIMediateur().mettreAJourInfo(commentaireGeneral.getText(),
dateImage.getRawValue(), noteVue.getNote());
 
}
});
 
// gestion des clics dans la grille
ExifGrid.addGridCellListener(new GridCellListenerAdapter() {
 
// lors d'un clic d'une cellule
 
@Override
public void onCellClick(GridPanel grid, int rowIndex, int colIndex,
EventObject e) {
 
// on empeche l'édition
e.stopEvent();
ExifGrid.stopEditing();
 
}
 
// lors du double clic sur une cellule
 
@Override
public void onCellDblClick(GridPanel grid, int rowIndex,
int colIndex, EventObject e) {
 
// on empêche l'édition
e.stopEvent();
ExifGrid.stopEditing();
 
}
 
});
 
IptcGrid.addGridCellListener(new GridCellListenerAdapter() {
 
// lors d'un clic d'une cellule
 
@Override
public void onCellClick(GridPanel grid, int rowIndex, int colIndex,
EventObject e) {
// on empeche l'édition
e.stopEvent();
ExifGrid.stopEditing();
 
}
 
// lors d'un double clic d'une cellule
@Override
public void onCellDblClick(GridPanel grid, int rowIndex,
int colIndex, EventObject e) {
// on empeche l'édition
e.stopEvent();
ExifGrid.stopEditing();
 
}
 
});
panneauMiniListeObservation.addListener(new ContainerListenerAdapter() {
@Override
public void onResize(BoxComponent component, int adjWidth, int adjHeight,
int rawWidth, int rawHeight) {
timerRedimensionnement = new Timer() {
@Override
public void run() {
int taille = 500;
if(Window.getClientHeight() > 800 ) {
taille = Window.getClientHeight() - 226;
}
panneauMiniListeObservation.setHeight(taille);
}
};
timerRedimensionnement.schedule(300);
}
});
panneauExifGrid.addListener(new ContainerListenerAdapter() {
@Override
public void onResize(BoxComponent component, int adjWidth, int adjHeight,
int rawWidth, int rawHeight) {
timerRedimensionnement = new Timer() {
@Override
public void run() {
int taille = 500;
taille = Window.getClientHeight() - 150;
ExifGrid.setHeight(taille);
panneauExifGrid.setHeight(taille);
}
};
timerRedimensionnement.schedule(300);
}
});
panneauExifGrid.addListener(new ContainerListenerAdapter() {
@Override
public void onResize(BoxComponent component, int adjWidth, int adjHeight,
int rawWidth, int rawHeight) {
timerRedimensionnement = new Timer() {
@Override
public void run() {
int taille = 500;
taille = Window.getClientHeight() - 150;
IptcGrid.setHeight(taille);
panneauIptcGrid.setHeight(taille);
}
};
timerRedimensionnement.schedule(300);
}
});
}
 
/**
* Desactive visuellement ce panneau
*/
public void desactiverPanneau() {
panneauInfoGrid.setDisabled(true);
panneauExifGrid.setDisabled(true);
panneauIptcGrid.setDisabled(true);
}
 
/**
* Active visuellement ce panneau
*/
public void activerPanneau() {
panneauInfoGrid.setDisabled(false);
panneauExifGrid.setDisabled(false);
panneauIptcGrid.setDisabled(false);
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return imediateur;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen de notification de mise à jour
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit un tableau d'objets
if (nouvelleDonnees instanceof Object[]) {
final Object ressourceObject = nouvelleDonnees;
if(!this.isRendered()) {
addListener(new PanelListenerAdapter() {
@Override
public void onRender(Component component) {
rafraichir(ressourceObject, false);
}
});
return ;
}
// extrait infos, exifs et iptc
Object meta[] = (Object[]) nouvelleDonnees;
String[][] exif = (String[][]) meta[0];
String[][] iptc = (String[][]) meta[1];
final String[][] gen = (String[][]) meta[2];
 
NameValuePair[] exifSource = new NameValuePair[exif.length];
NameValuePair[] iptcSource = new NameValuePair[iptc.length];
 
int maxLength;
if (exif.length <= iptc.length) {
maxLength = iptc.length;
} else {
maxLength = exif.length;
}
 
for (int i = 0; i < maxLength; i++) {
if (i < exif.length && !exif[i][0].equals("null")) {
exifSource[i] = new NameValuePair(exif[i][0], exif[i][1]);
}
 
if (i < iptc.length && !iptc[i][0].equals("null")) {
iptcSource[i] = new NameValuePair(iptc[i][0], iptc[i][1]);
}
}
 
// on met à jour les champs avec la bonne valeur
commentaireGeneral.setValue(gen[0][1]);
dateImage.setValue(gen[1][1]);
// et on met à jour les données pour l'affichage
ExifGrid.setSource(exifSource);
IptcGrid.setSource(iptcSource);
 
}
}
 
/**
* Accesseur pour le panneau des mots clés
*
* @return the panneauMotsCles
*/
public ImageMotsClesVue getPanneauMotsCles() {
return panneauMotsCles;
}
 
public BarreNotationVue getNoteVue() {
return noteVue;
}
public MiniListeObservationVue getMiniListeObservation()
{
return miniListeObservation ;
}
public RechercheFiltreTaxonVue getRechercheFiltreTaxonVue()
{
return rechercheFiltreTaxonVue ;
}
 
public void redimensionner() {
if(panneauMiniListeObservation.isCreated() && panneauMiniListeObservation.isVisible()) {
panneauMiniListeObservation.doLayout();
//panneauMiniListeObservation.show();
miniListeObservation.redimensionner();
}
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java
New file
0,0 → 1,235
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.MenuAideVue;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.SplitButton;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarMenuButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.SplitButtonListenerAdapter;
 
/**
* Barre d'outils contenant le menu de gestion des images (accessible aussi par
* un clic droit dans la galerie) et d'autres menus et boutons utiles
*
* @author aurelien
*
*/
public class BarreOutilsVue extends Toolbar {
 
/**
* Un bouton qui sert à déployer le menu
*/
ToolbarMenuButton images = null;
/**
* Un bouton qui sert à déployer le menu
*/
ToolbarMenuButton utilisateur = null;
/**
* Bouton pour déployer le menu d'aide
*/
ToolbarMenuButton aide = null ;
 
/**
* Le médiateur associé à la toolbar
*/
ImageMediateur iMediateur = null;
/**
* Le menu de gestion des images
*/
MenuImageVue imageMenu = null;
 
/**
* Le menu de gestion des filtres
*/
OptionsImages imageMenuEtendu = null;
/**
* L'item affichant les filtres en cours
*/
ToolbarTextItem texteFiltres;
 
/**
* Le menu de gestion utilisateur
*/
MenuIdVue idMenu = null;
/**
* Menu de gestion d'aide
*/
MenuAideVue aideMenu = null ;
 
/**
* Constructeur sans argument (ne doit pas être utilisé donc privé)
*/
@SuppressWarnings("unused")
private BarreOutilsVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer à la vue
*/
public BarreOutilsVue(ImageMediateur im) {
 
super();
 
iMediateur = im;
 
imageMenu = new MenuImageVue(im);
imageMenuEtendu = new OptionsImages(im);
//aideMenu = new MenuAideVue(im);
//images = new ToolbarMenuButton("Fichiers", imageMenu);
//aide = new ToolbarMenuButton("Aide", aideMenu);
texteFiltres = new ToolbarTextItem("");
final ToolbarMenuButton menuImage = new ToolbarMenuButton("Ajouter des images", imageMenuEtendu.getMenuImage());
menuImage.addListener(new SplitButtonListenerAdapter() {
 
@Override
public void onArrowClick(SplitButton menuButton, EventObject e) {
menuImage.showMenu();
}
 
@Override
public void onClick(Button button, EventObject e) {
menuImage.showMenu();
}
});
ToolbarButton menuSuppression = imageMenuEtendu.getBoutonSuppression();
final ToolbarMenuButton menuTampon = new ToolbarMenuButton("Tampon", imageMenuEtendu.getMenuTampon());
menuTampon.addListener(new SplitButtonListenerAdapter() {
 
@Override
public void onArrowClick(SplitButton menuButton, EventObject e) {
menuTampon.showMenu();
}
 
@Override
public void onClick(Button button, EventObject e) {
menuTampon.showMenu();
}
});
ToolbarButton menuGestionMotsCles = new ToolbarButton("Gérer les mots clés");
menuGestionMotsCles.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
getIMediateur().afficherFenetreGestionMotsCles();
}
});
this.addButton(menuImage);
this.addButton(menuSuppression);
this.addButton(menuGestionMotsCles);
this.addButton(menuTampon);
this.addItem(texteFiltres);
//this.addButton(aide);
}
 
/**
* @return the images
*/
public ToolbarMenuButton getImages() {
return images;
}
 
/**
* @return the iMediateur
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
public void setFiltresEnCours(String[][] filtresEnCours) {
String texteFiltresEnCours = "";
for(int i = 0; i < filtresEnCours.length; i++) {
if(Util.filtreValide(filtresEnCours[i])) {
if(!texteFiltresEnCours.equals("")) {
texteFiltresEnCours += " - ";
}
texteFiltresEnCours += "<span class=\"affichage_filtre\">"+
transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+
" <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_img_"+filtresEnCours[i][0]+"\" />"+
"</span>";
}
}
if(!texteFiltresEnCours.equals("")) {
texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>";
}
texteFiltres.setText(texteFiltresEnCours);
for(int i = 0; i < filtresEnCours.length; i++) {
if(Util.filtreValide(filtresEnCours[i])) {
if(Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]) != null) {
Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]).addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
e.stopEvent();
iMediateur.viderFiltre(e.getTarget().getAttribute("rel"));
}
});
}
}
}
}
private String transformerNomFiltre(String nomFiltre) {
if(nomFiltre.equals("id_mots_cles")) {
nomFiltre = "mots clés";
}
return nomFiltre;
}
private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) {
String valeurFiltreTransformee = valeurFiltre;
if(nomFiltre.equals("id_mots_cles")) {
String[] tabMotsCles = valeurFiltre.split(";");
String[] tabMotsClesTexte = iMediateur.getTexteMotsCles(tabMotsCles);
if(tabMotsClesTexte.length > 1) {
valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte);
} else {
valeurFiltreTransformee = tabMotsClesTexte[0];
}
}
if(nomFiltre.equals("mois")) {
valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre));
}
 
return valeurFiltreTransformee;
}
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java
New file
0,0 → 1,691
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragDrop;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.HorizontalLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.tree.MultiSelectionModel;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**
* Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
* clés cochables et réorganisables à volonté
*
* @author aurelien
*
*/
public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable {
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreMotsCles = null;
/**
* L'éditeur qui permet de modifier les mots clés dans l'arbre
*/
private TreeEditor te = null;
/**
* Le textfield associé à l'éditeur
*/
private TextField tfEdit = null;
/**
* Bouton de validation
*/
private Button valider = null;
/**
* Bouton d'annulation
*/
private Button annuler = null;
/**
* Bouton d'ajout de tag
*/
private ToolbarButton ajouterTag = null;
/**
* Bouton de suppression de tag
*/
private ToolbarButton supprimerTag = null;
/**
* Bouton de renommage de tag
*/
private ToolbarButton renommerTag = null;
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par
* des virgules
*/
private String motsClesEnCours = "";
private String[] tableauMotsClesEnCours = new String[0];
/**
* Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
* (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
* du conteneur n'ai été effectué)
*/
private String[] motsClesEnAttente = new String[0];
/**
* Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
* noeud
*/
private boolean ajoutNoeud = false;
/**
* Booléen d'évènement qui sert à savoir si on est en train de modifier un
* noeud
*/
private boolean modifNoeud = false;
/**
* Booléen d'instanciation du conteneur
*/
private boolean arbreCharge = false;
/**
* Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
*/
private boolean motsCleInitialises;
/**
* panneau intermédiaire contenant l'arbre
*/
private Panel panelIntermediaire;
private String cheminTemporaireAjout;
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public FenetreGestionMotsCles() {
// on crée le panel
setTitle("Mots clés");
this.setLayoutData(new RowLayout());
 
// on crée le conteneur de l'arbre
arbreMotsCles = new TreePanel();
// on permet le drag and drop dans l'arbre
arbreMotsCles.setEnableDD(true);
arbreMotsCles.setId("x-view-tree-keyword-imgs");
 
arbreMotsCles.setSelectionModel(new MultiSelectionModel());
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine");
String[] usObject = { "Mots clés", "racine" };
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
arbreMotsCles.setWidth(500);
root.setUserObject(usObject);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
 
@Override
public void onClick(Node node, EventObject e) {
if(!arbreCharge) {
expand();
}
}
 
@Override
public void onExpand(Node node) {
if(!arbreCharge) {
obtenirArbreMotsCles();
arbreCharge = true;
}
}
 
});
 
// on crée l'éditeur pour l'arbre
tfEdit = new TextField();
tfEdit.setAutoWidth(true);
te = new TreeEditor(arbreMotsCles, tfEdit);
valider = new Button("Appliquer");
annuler = new Button("Annuler");
arbreMotsCles.add(te);
panelIntermediaire = new Panel();
panelIntermediaire.setLayout(new FitLayout());
panelIntermediaire.setAutoScroll(true);
panelIntermediaire.setWidth("100%");
arbreMotsCles.setWidth("100%");
arbreMotsCles.setHeight("100%");
Panel panelBoutons = new Panel();
panelBoutons.setLayout(new HorizontalLayout(130));
panelBoutons.setWidth("100%");
 
// on met en forme le layout
panelIntermediaire.add(arbreMotsCles);
panelBoutons.add(annuler);
panelBoutons.add(valider);
this.add(panelIntermediaire, new RowLayoutData());
this.add(panelBoutons, new RowLayoutData(30));
arbreMotsCles.setHeight("100%");
arbreMotsCles.setAutoScroll(true);
Toolbar barreBouton = new Toolbar();
ajouterTag = new ToolbarButton("Nouveau Tag");
ajouterTag.setIcon("mot_cle_ajouter.png");
renommerTag = new ToolbarButton("Renommer");
renommerTag.setIcon("mot_cle_editer.png");
renommerTag.disable();
supprimerTag = new ToolbarButton("Supprimer");
supprimerTag.setIcon("mot_cle_supprimer.png");
supprimerTag.disable();
barreBouton.addButton(ajouterTag);
barreBouton.addSeparator();
barreBouton.addButton(renommerTag);
barreBouton.addSeparator();
barreBouton.addButton(supprimerTag);
this.setTopToolbar(barreBouton);
setCloseAction(com.gwtext.client.widgets.Window.HIDE);
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Acesseur pour l'arbre des mots clés
*
* @return le panel contenant l'arbre
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Accesseur pour l'éditeur
*
* @return l'éditeur associé à l'arbre
*/
public TreeEditor getTe() {
return te;
}
 
/**
* Acesseur pour le TextField associé à l'éditeur
*
* @return le champ texte associé à l'éditeur
*/
public TextField getTfEdit() {
return tfEdit;
}
protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te);
protected abstract void surAjoutMotCle(TreeNode node, Tree arbre);
protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre);
protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre);
protected abstract void surChangementTexte(TreeNode node, Tree arbre);
protected abstract void surClicValider(String chaineMotsCles, Tree arbre);
protected abstract void demanderArbreMotsCles(Rafraichissable r);
protected abstract void surRetourWebService(Tree arbre);
 
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners() {
this.addListener(new WindowListenerAdapter() {
@Override
public void onResize(com.gwtext.client.widgets.Window source, int width,
int height) {
panelIntermediaire.setHeight(getHeight() - 80);
}
});
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
@Override
public void onAfterLayout(Container self) {
panelIntermediaire.setHeight(getHeight() - 80);
}
@Override
public void onExpandNode(TreeNode node) {
cocherMotsCles(tableauMotsClesEnCours);
}
 
// gestion du clic sur un noeud
@Override
public void onClick(TreeNode node, EventObject e) {
 
e.stopEvent();
gererClicNoeud(node);
if(!node.equals(arbreMotsCles.getRootNode())) {
supprimerTag.enable();
renommerTag.enable();
}
}
 
// gestion du clic droit sur un noeud
@Override
public void onContextMenu(TreeNode node, EventObject e) {
 
e.stopEvent();
surAffichageMenuContextuel(node, e, getTe());
if(!node.equals(arbreMotsCles.getRootNode())) {
supprimerTag.enable();
renommerTag.enable();
}
}
 
// gestion de la modification du texte d'un noeud
@Override
public void onTextChange(TreeNode node, String text, String oldText) {
if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
te.startEdit(node);
Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
return;
}
if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
te.startEdit(node);
Window.alert("Un mot clé de même nom existe déjà à cette position");
return;
}
 
if(node.equals(arbreMotsCles.getRootNode())) {
return;
}
 
// on récupère les informations associées au noeud
TreeNode nd = node;
String[] usObject = new String[2];
usObject[0] = text;
usObject[1] = ((String[]) nd.getUserObject())[1];
nd.setUserObject(usObject);
 
// si c'est un nouveau noeud
if (ajoutNoeud) {
// on considère l'ajout achevé
ajoutNoeud = false;
// et on notifie le médiateur de l'ajout et on lui passe
// l'arbre
surAjoutMotCle(nd, getArbreMotsCles().getTree());
arbreMotsCles.disable();
}
// si c'est noeud déjà existant
else {
// on considère la modification achevée
modifNoeud = false;
if(!text.equals(oldText)) {
// et on notifie le médiateur de la modification et on lui
// passe l'arbre
surChangementTexte(nd, getArbreMotsCles().getTree());
arbreMotsCles.disable();
}
}
}
@Override
public boolean doBeforeMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
boolean ok = true;
if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
ok = false;
Window.alert("Un mot clé de même nom existe déjà à cette position");
}
return ok;
}
@Override
public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
DragData dragData, String point, DragDrop source,
TreeNode dropNode) {
return MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
}
 
// gestion du déplacement d'un noeud
@Override
public void onMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
// on notifie le médiateur et on lui passe l'arbre
surDeplacementMotCle(node, getArbreMotsCles().getTree());
}
 
});
 
// gestion de la validation
valider.addListener(new ButtonListenerAdapter() {
 
// lors du clic
@Override
public void onClick(Button button, EventObject e) {
 
// on vide les mots clés en cours
motsClesEnCours = "";
// pour chaque noeud à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// on éxécute une fonction
@Override
public boolean execute(Node node) {
 
// on récupère le mot clé associé au noeud et
// ses infos
TreeNode tn = getArbreMotsCles().getNodeById(
node.getId());
 
String[] usObject = (String[]) tn
.getUserObject();
/*getIMediateur().mettreAjourMotsClesId(
usObject[0], usObject[1]);*/
 
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots
// clés en cours
motsClesEnCours += usObject[1] + ",";
}
 
return true;
}
 
});
 
// enfin on notifie le médiateur et on lui passe l'arbre et la
// liste des mots clés ainsi obtenue
surClicValider(motsClesEnCours, arbreMotsCles.getTree());
}
});
annuler.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
hide();
}
});
renommerTag.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
TreeNode noeudRenommage;
if(noeuds.length > 0) {
noeudRenommage = noeuds[noeuds.length - 1];
} else {
noeudRenommage = arbreMotsCles.getRootNode();
}
renommerNoeud(noeudRenommage);
}
});
ajouterTag.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
TreeNode noeudAjout;
if(noeuds.length > 0) {
noeudAjout = noeuds[noeuds.length - 1];
} else {
noeudAjout = arbreMotsCles.getRootNode();
}
 
ajouterNoeud(noeudAjout);
}
});
supprimerTag.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
for (int i = 0; i < noeuds.length; i++) {
supprimerNoeud(noeuds[i]);
}
}
});
}
 
/**
* Envoie une demande au médiateur pour obtenir l'arbre des mots clés
*/
public void obtenirArbreMotsCles() {
demanderArbreMotsCles(this);
}
 
/**
* Supprime un noeud de l'arbre
*
* @param n
* le noeud à supprimer
*/
public void supprimerNoeud(TreeNode n) {
// si ça n'est pas la racine (qu'on ne peut pas supprimer)
if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
// on détache le noeud et on le détruit
n.getParentNode().removeChild(n);
n.destroy();
// puis on en notifie le médiateur en lui passant le noeud supprimé
// et l'arbre
surSuppressionMotCle(n, arbreMotsCles.getTree());
}
} else {
// si l'utilisateur tente de supprimer la racine, on l'avertit de
// son erreur
Window.alert("Impossible de supprimer la racine de l'arbre");
}
}
 
/**
* Ajoute un noeud dans l'arbre au parent donné
*
* @param parent
* le futur parent du noeud à ajouter
*/
public void ajouterNoeud(TreeNode parent) {
ajoutNoeud = true;
TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
cheminTemporaireAjout = nd.getId();
te.startEdit(nd);
}
 
/**
* Renomme le noeud passé en paramètre
*/
public void renommerNoeud(TreeNode n) {
// TODO Auto-generated method stub
te.startEdit(n);
}
 
/**
* Coche le noeud s'il est décoché, le décoche sinon
*
* @param node
*/
public void gererClicNoeud(TreeNode node) {
if (node.getUI().isChecked()) {
node.getUI().toggleCheck(false);
} else {
node.getUI().toggleCheck(true);
}
}
 
/**
* Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
* clés à cocher
*
* @param motsClesIds
* un tableau contenant les identifiants des mots clés à cocher
*/
public void cocherMotsCles(final String[] motsClesIds) {
if (getArbreMotsCles() != null
&& getArbreMotsCles().getRootNode() != null) {
// à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// pour chaque noeud
@Override
public boolean execute(Node node) {
 
String usObject[] = (String[]) node
.getUserObject();
String nodeId = usObject[1];
TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
if(tn != null) {
tn.getUI().toggleCheck(false);
// on parcourt le tableau des mots clés
for (int i = 0; i < motsClesIds.length; i++) {
// si le mot clé fait partie des id à cocher on
// le coche
 
if (nodeId.equals(motsClesIds[i])) {
tn.getUI().toggleCheck(true);
tn.ensureVisible();
return true;
}
}
// et on passe au suivant
}
return true;
}
 
});
}
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données pour l'objet
* @param repandreRafraichissement
* booleen qui dit si on doit répandre l'évenement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
if(nouvelleDonnees instanceof Tree) {
 
Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
// on prend sa racine et on l'attache à l'arbre des mots clés
Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
 
// si l'arbre n'était pas encore considéré comme instancié
if (!arbreCharge) {
// on signale que oui
arbreCharge = true;
}
}
 
// Si on reçoit un tableau de String (cas ou l'on séléectionne une
// nouvelle image)
if (nouvelleDonnees instanceof String[]) {
 
// le tableau de String contient les id des mots clés associés à
// l'image
// on coche les mots clés contenu dans le tableau
tableauMotsClesEnCours = (String[]) nouvelleDonnees;
if(this.isVisible()) {
cocherMotsCles(tableauMotsClesEnCours);
} else {
addListener(new WindowListenerAdapter() {
@Override
public void onShow(Component component) {
cocherMotsCles(tableauMotsClesEnCours);
}
});
}
}
// reception d'un nouvel identifiant de mot clé
if(nouvelleDonnees instanceof Integer) {
if(cheminTemporaireAjout != null) {
String id = ((Integer)(nouvelleDonnees)).toString();
TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
String[] userObj = {noeudEnAjout.getText(), id};
noeudEnAjout.setUserObject(userObj);
cheminTemporaireAjout = null;
}
}
surRetourWebService(arbreMotsCles.getTree());
arbreMotsCles.enable();
}
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1]);
child.setChecked(false);
child.setUserObject(usObj);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
 
public void activerBoutonValider(boolean activer) {
valider.setVisible(activer);
}
}
 
/branches/v2.8-houe/src/org/tela_botanica/client/vues/image/GalerieImageVue.java
New file
0,0 → 1,575
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
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.vues.BarrePaginationVue;
 
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.XTemplate;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.util.Format;
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.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.DataViewListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
 
/**
* Galerie d'images miniatures Avec barre de pagination
*
* @author aurelien
*/
public class GalerieImageVue extends Panel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* instance du médiateur
*/
private ImageMediateur iMediateur = null;
/**
* Dataview, littéralement "vue de données" qui permet de définir la manière
* d'afficher les données
*/
private DataView dView = null;
/**
* Dataview, littéralement "vue de données" qui permet de définir la manière
* d'afficher les données
*/
private Store st = null;
/**
* Barre de pagination gérant l'affichage d'un nombre donné d'élements par
* page et la navigation entre eux
*/
private BarrePaginationVue pt = null;
/**
* Booleen indiquant si la galerie est instanciée ou pas
*/
private boolean estInstancie = false;
private boolean garderRatio = true;
private int tailleOr = 100 ;
boolean lienUploadInitialise = false ;
HTML videPanel = null ;
 
 
/**
* Constructeur sans argument, privé car ne doit pas être utilisé
*/
@SuppressWarnings("unused")
private GalerieImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur avec lequel la vue va communiquer
*/
public GalerieImageVue(ImageMediateur im) {
super("Galerie");
iMediateur = im;
// on ajoute des listeners au composant tout entier
this.addListener(new ContainerListenerAdapter() {
 
// pour gagner du temps on n'instancie la vue en elle même que lors
// du premier affichage (lazy rendering)
@Override
public void onShow(Component component) {
 
if (!estInstancie) {
initialiser();
}
}
});
AjouterListenersLiens();
 
// et on ajoute la tool bar
pt = new BarrePaginationVue(this);
pt.setLabelElement("Images");
pt.setTaillePageParDefaut(50);
this.setBottomToolbar(pt);
 
}
 
/**
* Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la
* vue de données
*/
public void ajouterListenersDataView() {
 
// ajout de listeners pour la gestion de la selection
// dans la galerie
dView.addListener(new DataViewListenerAdapter() {
 
// gestion du clic sur une image
 
@Override
public void onClick(DataView source, int index, Element node,
EventObject e) {
// on en notifie le médiateur
getIMediateur().clicGalerieImage(index, node, e);
 
}
 
// gestion du clic droit
 
@Override
public void onContextMenu(DataView source, int index, Element node,
EventObject e) {
 
// on stoppe l'évenement
e.stopEvent();
// et on notifie le médiateur
getIMediateur().montrerContextMenu(e);
 
}
 
// gestion du double clic
 
@Override
public void onDblClick(DataView source, int index, Element node,
EventObject e) {
 
// on notife le mediateur
getIMediateur().clicGalerieImage(index, node, e);
 
}
 
// gestion des actions en fonction de la selection
 
@Override
public void onSelectionChange(DataView view, Element[] selections) {
 
// s'il n'y a aucun élement sélectionné
if (selections.length <= 0) {
// on en notifie le médiateur
getIMediateur().aucuneSelection();
} else {
// sinon on notifie le médiateur
getIMediateur().selection();
// et on lui demande de synchroniser la séléction avec les
// autres vues
getIMediateur().synchroniserSelection("galerie");
}
}
});
}
 
/**
* Accesseur pour la dataview
*
* @return la dataview
*/
public DataView getDView() {
return dView;
}
 
/**
* Renvoie les ids des images sélectionnées
*
* @return un tableau de String contenant les identifiants des images
* sélectionnées
*/
@Override
public String[] getIdSelectionnees() {
Record[] selection = getDView().getSelectedRecords();
int taille = selection.length;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("num_image");
}
 
return id_selection;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur pour le store
*
* @return le store associé à la vue
*/
public Store getSt() {
return st;
}
 
/**
* Accesseur pour la toolbar
*
* @return la toolbar associée à la vue
*/
public BarrePaginationVue getToolBarVue() {
return pt;
}
 
/**
* Fonction d'initialisation du contenu (appelée lors du premier affichage
* de la liste)
*/
public void initialiser() {
 
// Preparation de la dataview et du template
// le template va créer une div contenant une image
// pour chacune des photos
final XTemplate template = new XTemplate(
new String[] {
"<tpl for='.'>",
"<div class='thumb-wrap' id='{num_image}'>",
"<div class='thumb dview-list'>{indication_transmission}{indication_liaison}<img class='miniature_galerie' src='{url_image_M}' width='{taille_x_s} px' height='{taille_y_s} px' title='{infobulle}' /></div>",
"<span class='info_image'>{nom_obs_associees_formatees}</span></div>", "</tpl>",
"<div class='x-clear'></div>" });
// pour des raisons de performances on compile le template en une
// fonction
template.compile();
 
// la dataview affichera les images en accord avec le template
// cree precedemment
dView = new DataView("div.thumb-wrap") {
 
@Override
public void prepareData(Data data) {
data.setProperty("shortName", Format.ellipsis(data
.getProperty("nom_original"), 15));
int[] XY = {data.getPropertyAsInt("taille_x") ,data.getPropertyAsInt("taille_y")} ;
int[] XYresize ;
if(garderRatio) {
XYresize = calculerDimensions(XY);
}
else {
XYresize = new int[2] ;
XYresize[0] = XYresize[1] = tailleOr ;
}
data.setProperty("taille_x_s", XYresize[0]);
data.setProperty("taille_y_s", XYresize[1]);
String nomObs = data.getProperty("obs_associees");
 
String htmltransmis = "";
String htmllie = "";
boolean associee = estAssocieeTransmise(nomObs)[0];
boolean transmise = estAssocieeTransmise(nomObs)[1];
String nomFormate = getNomsObservationsFormatees(nomObs);
if(associee) {
htmllie = "<img class='picto_haut_droite' src='chain.png' />";
}
if(transmise) {
htmltransmis = "<img class='picto_haut_gauche' src='tela.png' />";
}
 
data.setProperty("infobulle", nomFormate);
data.setProperty("indication_transmission", htmltransmis);
data.setProperty("indication_liaison", htmllie);
data.setProperty("nom_obs_associees_formatees", nomFormate);
}
};
dView.setTpl(template);
 
// parametre d'affichage de la dataview
this.setAutoScroll(true);
dView.setAutoHeight(true);
dView.setMultiSelect(true);
dView.setOverCls("x-view-over");
dView.setEmptyText("");
 
// creation du store
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defNomImage = new StringFieldDef("nom_original");
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 defTailleX = new IntegerFieldDef("taille_x");
FieldDef defTailleY = new IntegerFieldDef("taille_y");
FieldDef defObsAssociees = new StringFieldDef("obs_associees");
FieldDef[] defTab = { defNumImage, defNomImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,defTailleX,defTailleY, defObsAssociees};
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
dView.setStore(st);
 
this.getDView().setLoadingText("chargement");
 
this.add(dView);
dView.hide();
videPanel = new HTML("<div class=\"avertissement\" >Aucune image à afficher. <br/> <a id=\"lienUploadMultiple\" href=\"#\" > Cliquez ici pour ajouter un dossier entier ou plusieurs fichiers </a> (nécessite Java) <br/> " +
" <a id=\"lienUploadSimple\" href=\"#\" > Cliquez ici pour ajouter un fichier à la fois </a> <br/> " +
" Pour ajouter des images plus tard, allez dans le menu Fichier -> Ajouter des images </div>");
this.add(videPanel);
// ajouts de la gestion des evenements pour la dataview
configDragAndDrop() ;
ajouterListenersDataView();
estInstancie = true ;
}
public void configDragAndDrop()
{
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
@Override
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si les données proviennent d'une grille
if(data instanceof GridDragData)
{
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
return false ;
}
@Override
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si l'objet reçu est un store
if (nouvelleDonnees instanceof Store) {
 
st = (Store) nouvelleDonnees;
if(st.getCount() != 0) {
// on le charge
st.load();
if(videPanel != null && videPanel.isVisible()) {
videPanel.setVisible(false) ;
}
if(dView != null) {
if(!dView.isVisible()) {
dView.setVisible(true);
}
// on l'affecte à la vue
dView.setStore(st);
// et on rafrachit la vue
dView.refresh();
}
}
else
{
st.removeAll();
st.load();
dView.setStore(st);
if(dView.isVisible()) {
dView.hide() ;
}
if(videPanel != null && !videPanel.isVisible()) {
videPanel.setVisible(true);
AjouterListenersLiens();
}
}
}
 
// si le composant doit répandre le rafraichissement
if (repandreRafraichissement) {
// il en notifie le médiateur en lui donnant une copie des données
// et en notifiant qu'il en est l'expéditeur
getIMediateur().synchroniserDonneesZoomListeGalerie(
nouvelleDonnees, this);
}
}
 
/**
* Méthode héritée de l'interface VueListable Sélectionne les images dans la
* galerie suivant les identifiants donnés en paramètres
*
* @param ids
* les identifiants des images à sélectionner
*/
public void selectionnerImages(int[] ids) {
 
getDView().select(ids);
 
}
 
@Override
public void changerNumeroPage(int pageCourante) {
iMediateur.changerNumeroPage(pageCourante) ;
}
 
@Override
public void changerTaillePage(int nouvelleTaillePage) {
iMediateur.changerTaillePage(nouvelleTaillePage) ;
}
public int[] calculerDimensions(int[] tailleXY) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = this.tailleOr ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
return res;
}
private void AjouterListenersLiens() {
 
addListener(new PanelListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
ExtElement uploadS = Ext.get("lienUploadSimple");
uploadS.removeAllListeners();
uploadS.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
getIMediateur().uploaderImages(false);
}
}) ;
ExtElement uploadM = Ext.get("lienUploadMultiple");
uploadM.removeAllListeners();
uploadM.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
getIMediateur().uploaderImages(true);
}
});
}
 
});
}
private String getNomsObservationsFormatees(String nomObs) {
String htmlInfobulle = "";
String[][] obs = getObservationsAssociees(nomObs);
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) {
htmlInfobulle += ", "+obs[i][1];
}
}
htmlInfobulle = htmlInfobulle.replaceFirst(", ", "");
return htmlInfobulle;
}
private String[][] getObservationsAssociees(String nomObs) {
if(nomObs.trim().equals("")) {
return new String[0][0];
}
String[] obsTab = nomObs.split(";;");
String[][] obsAnalysees = new String[obsTab.length][3];
for(int i = 0; i < obsTab.length; i++) {
obsAnalysees[i] = obsTab[i].split("#");
}
return obsAnalysees;
}
private boolean[] estAssocieeTransmise(String nomObs) {
String[][] obs = getObservationsAssociees(nomObs);
boolean[] associeesTranmises = {false, false};
if(obs.length > 0) {
associeesTranmises[0] = true;
}
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) {
associeesTranmises[1] = true;
}
}
return associeesTranmises;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java
New file
0,0 → 1,233
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.user.client.Timer;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.layout.HorizontalLayout;
import com.gwtext.client.widgets.layout.RowLayout;
 
public class ListeUtilisateurAdminVue extends Window implements Rafraichissable {
 
private CarnetEnLigneMediateur cMediateur = null ;
private ComboBox listeUtil = null ;
private Store storeUtil = null ;
private com.gwtext.client.widgets.Button OK = null;
private com.gwtext.client.widgets.Button annuler = null;
private boolean selectionUtilisateur =false;
public String utilisateur = null;
public String idUtilisateur = null;
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
private Timer timerCompletion = null;
public ListeUtilisateurAdminVue(CarnetEnLigneMediateur cMed) {
super("Choisir un utilisateur") ;
this.cMediateur = cMed;
listeUtil=new ComboBox("Utilisateurs","courriel",280);
this.setLayout(new RowLayout());
final String resultTplUtil = "<div class=\"search-item-utilisateur\">{courriel}</div>";
utilisateur = cMediateur.getUtilisateur().getLoginUtilisateurConsulte();
idUtilisateur = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte();
 
listeUtil.setTpl(resultTplUtil);
listeUtil.setMode(ComboBox.REMOTE);
listeUtil.setItemSelector("div.search-item-utilisateur");
listeUtil.setHideTrigger(true);
listeUtil.setDisplayField("courriel");
listeUtil.setLoadingText("Recherche...");
listeUtil.setValue(utilisateur);
OK= new com.gwtext.client.widgets.Button("OK");
annuler = new com.gwtext.client.widgets.Button("Annuler");
Panel boutonPanel = new Panel();
boutonPanel.setLayout(new HorizontalLayout(0));
add(listeUtil);
boutonPanel.add(OK);
boutonPanel.add(annuler);
add(boutonPanel);
this.setSize(300, 75);
OK.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(com.gwtext.client.widgets.Button button,
EventObject e) {
if(valider()) {
cMediateur.changerIdentite(idUtilisateur,utilisateur);
close();
}
}
});
annuler.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(com.gwtext.client.widgets.Button button,
EventObject e) {
close();
}
});
ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
listenerConfigAutocompletion.setDelay(200);
listenerConfigAutocompletion.setStopPropagation(false);
listenerConfigAutocompletion.setStopEvent(false);
listeUtil.addKeyPressListener(new EventCallback() {
 
@Override
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if(selectionUtilisateur) {
selectionUtilisateur=false;
}
else {
if(valider()) {
cMediateur.changerIdentite(idUtilisateur,utilisateur);
}
close();
}
break;
default:
if(timerCompletion != null) {
timerCompletion.cancel();
}
timerCompletion = new Timer() {
public void run() {
obtenirListeUtilisateur();
}
};
timerCompletion.schedule(250);
break;
}
}
}, listenerConfigAutocompletion);
listeUtil.addListener(new ComboBoxListenerAdapter() {
 
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
utilisateur = record.getAsString("courriel");
idUtilisateur = record.getAsString("id_utilisateur");
listeUtil.setValue(utilisateur);
}
});
}
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof String[][]) {
Object[][] utilData = (Object[][])nouvelleDonnees ;
FieldDef defId = new StringFieldDef("id_utilisateur");
FieldDef defCourriel = new StringFieldDef("courriel");
FieldDef[] defTab = {defId,defCourriel};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(utilData);
final ArrayReader reader = new ArrayReader(rd);
storeUtil =new Store(dataProxy,reader);
storeUtil.load() ;
listeUtil.setStore(storeUtil);
// Tentative de corriger un bug insupportable de la taille de la liste
// mais ça ne marche pas à tous les coups
listeUtil.collapse();
listeUtil.expand();
}
}
private boolean valider() {
if(listeUtil.getValue() != null) {
return true;
}
return false;
}
public void obtenirListeUtilisateur() {
String valeur = listeUtil.getRawValue();
cMediateur.obtenirListeUtilisateurs(valeur,this) ;
}
 
public void focusChampUtilisateur() {
listeUtil.focus();
}
 
}
Property changes:
Added: svn:ignore
+.project
+tomcat
Added: svn:mergeinfo
Merged /branches/v1.0-beche/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java:r290-316
/branches/v2.8-houe/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
New file
0,0 → 1,466
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**
* Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
* clés cochables et réorganisables à volonté
*
* @author aurelien
*
*/
public class ArbreMotsClesVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreMotsCles = null;
/**
* L'éditeur qui permet de modifier les mots clés dans l'arbre
*/
private TreeEditor te = null;
/**
* Le textfield associé à l'éditeur
*/
private TextField tfEdit = null;
/**
* Bouton de validation
*/
private Button valider = null;
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par
* des virgules
*/
private String motsClesEnCours = "";
private String[] tableauMotsClesEnCours = new String[0];
/**
* Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
* (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
* du conteneur n'ai été effectué)
*/
private String[] motsClesEnAttente = new String[0];
/**
* Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
* noeud
*/
private boolean ajoutNoeud = false;
/**
* Booléen d'évènement qui sert à savoir si on est en train de modifier un
* noeud
*/
private boolean modifNoeud = false;
/**
* Booléen d'instanciation du conteneur
*/
private boolean arbreCharge = false;
/**
* Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
*/
private boolean motsCleInitialises;
 
private String cheminTemporaireAjout;
 
/**
* Constructeur sans paramètre (privé car interdit d'utilisation)
*/
@SuppressWarnings("unused")
private ArbreMotsClesVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesVue(ImageMediateur im) {
// on crée le panel
super("Mots clés");
this.setLayout(new VerticalLayout());
iMediateur = im;
 
// on crée le conteneur de l'arbre
arbreMotsCles = new TreePanel();
// on permet le drag and drop dans l'arbre
arbreMotsCles.setEnableDD(true);
arbreMotsCles.setId("x-view-tree-keyword");
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine");
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
arbreMotsCles.setRootNode(root);
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
arbreMotsCles.setWidth(500);
 
// on crée l'éditeur pour l'arbre
tfEdit = new TextField();
tfEdit.setAutoWidth(true);
te = new TreeEditor(arbreMotsCles, tfEdit);
valider = new Button("Appliquer");
arbreMotsCles.add(te);
 
// on met en forme le layout
this.add(arbreMotsCles);
this.add(valider);
 
this.setBorder(false);
this.setCollapsible(true);
this.setTitleCollapse(true);
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Acesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
private ImageMediateur getIMediateur() {
 
return iMediateur;
 
}
 
/**
* Acesseur pour l'arbre des mots clés
*
* @return le panel contenant l'arbre
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Accesseur pour l'éditeur
*
* @return l'éditeur associé à l'arbre
*/
public TreeEditor getTe() {
return te;
}
 
/**
* Acesseur pour le TextField associé à l'éditeur
*
* @return le champ texte associé à l'éditeur
*/
public TextField getTfEdit() {
return tfEdit;
}
 
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners() {
final Rafraichissable r = this;
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
 
@Override
public void onExpandNode(TreeNode node) {
cocherMotsCles(tableauMotsClesEnCours);
}
// gestion du clic sur un noeud
@Override
public void onClick(TreeNode node, EventObject e) {
e.stopEvent();
gererClicNoeud(node);
}
 
// gestion du clic droit sur un noeud
@Override
public void onContextMenu(TreeNode node, EventObject e) {
e.stopEvent();
getIMediateur().montrerContextMenuArbre(node, e, getTe());
}
 
// gestion du double clic sur un noeud
@Override
public void onDblClick(TreeNode node, EventObject e) {
modifNoeud = true;
if (!node.getId().equals("racine")) {
te.startEdit(node);
}
}
 
// gestion de la modification du texte d'un noeud
@Override
public void onTextChange(TreeNode node, String text, String oldText) {
 
// on récupère les informations associées au noeud
TreeNode nd = node;
String[] usObject = new String[2];
usObject[0] = text;
usObject[1] = ((String[]) nd.getUserObject())[1];
nd.setUserObject(usObject);
 
// si c'est un nouveau noeud
if (ajoutNoeud) {
// on considère l'ajout achevé
ajoutNoeud = false;
// et on notifie le médiateur de l'ajout et on lui passe
// l'arbre
getIMediateur().ajouterMotCleDansArbre(nd,
getArbreMotsCles().getTree(), ArbreMotsClesVue.this);
}
// si c'est noeud déjà existant
else {
// et on considère la modification achevée
modifNoeud = false;
// on notifie le médiateur de la modification et on lui
// passe l'arbre
getIMediateur().modifierMotCleDansArbre(nd,
getArbreMotsCles().getTree(), ArbreMotsClesVue.this);
}
 
}
 
// gestion du déplacement d'un noeud
@Override
public void onMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
// on notifie le médiateur et on lui passe l'arbre
getIMediateur().deplacerMotCleDansArbre(node,
getArbreMotsCles().getTree(), ArbreMotsClesVue.this);
}
 
});
 
// gestion de la validation
valider.addListener(new ButtonListenerAdapter() {
 
// lors du clic
@Override
public void onClick(Button button, EventObject e) {
 
// on vide les mots clés en cours
motsClesEnCours = "";
// pour chaque noeud à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// on éxécute une fonction
@Override
public boolean execute(Node node) {
 
// on récupère le mot clé associé au noeud et
// ses infos
TreeNode tn = getArbreMotsCles().getNodeById(
node.getId());
 
String[] usObject = (String[]) tn
.getUserObject();
getIMediateur().mettreAjourMotsClesId(
usObject[0], usObject[1]);
 
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots
// clés en cours
motsClesEnCours += usObject[1] + ",";
}
 
return true;
}
 
});
 
// enfin on notifie le médiateur et on lui passe l'arbre et la
// liste des mots clés ainsi obtenue
getIMediateur().mettreAjourMotsCles(motsClesEnCours,
arbreMotsCles.getTree());
}
});
}
 
/**
* Envoie une demande au médiateur pour obtenir l'arbre des mots clés
*/
public void obtenirArbreMotsCles() {
 
getIMediateur().obtenirArbreMotsCles(this);
 
}
 
/**
* Supprime un noeud de l'arbre
*
* @param n
* le noeud à supprimer
*/
public void supprimerNoeud(TreeNode n) {
// si ça n'est pas la racine (qu'on ne peut pas supprimer)
if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
// on détache le noeud et on le détruit
n.getParentNode().removeChild(n);
n.destroy();
// puis on en notifie le médiateur en lui passant le noeud supprimé
// et l'arbre
getIMediateur()
.supprimerMotCleDansArbre(n, arbreMotsCles.getTree(), ArbreMotsClesVue.this);
} else {
// si l'utilisateur tente de supprimer la racine, on l'avertit de
// son erreur
Window.alert("Impossible de supprimer la racine de l'arbre");
}
}
 
/**
* Ajoute un noeud dans l'arbre au parent donné
*
* @param parent
* le futur parent du noeud à ajouter
*/
public void ajouterNoeud(TreeNode parent) {
ajoutNoeud = true;
TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
cheminTemporaireAjout = nd.getId();
te.startEdit(nd);
}
 
/**
* Coche le noeud s'il est décoché, le décoche sinon
*
* @param node
*/
public void gererClicNoeud(TreeNode node) {
if (node.getUI().isChecked()) {
node.getUI().toggleCheck(false);
} else {
node.getUI().toggleCheck(true);
}
}
 
/**
* Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
* clés à cocher
*
* @param motsClesIds
* un tableau contenant les identifiants des mots clés à cocher
*/
public void cocherMotsCles(final String[] motsClesIds) {
if (getArbreMotsCles() != null
&& getArbreMotsCles().getRootNode() != null) {
// à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// pour chaque noeud
@Override
public boolean execute(Node node) {
 
getArbreMotsCles().getNodeById(node.getId())
.getUI().toggleCheck(false);
// on parcourt le tableau des mots clés
for (int i = 0; i < motsClesIds.length; i++) {
// si le mot clé fait partie des id à cocher on
// le coche
String usObject[] = (String[]) node
.getUserObject();
String nodeId = usObject[1];
 
if (nodeId.equals(motsClesIds[i])) {
getArbreMotsCles().getNodeById(nodeId)
.getUI().toggleCheck(true);
return true;
}
}
// et on passe au suivant
return true;
}
 
});
}
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données pour l'objet
* @param repandreRafraichissement
* booleen qui dit si on doit répandre l'évenement
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
if(nouvelleDonnees instanceof Tree) {
 
Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
// on prend sa racine et on l'attache à l'arbre des mots clés
Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), true);
 
// si l'arbre n'était pas encore considéré comme instancié
if (!arbreCharge) {
// on signale que oui
arbreCharge = true;
}
}
 
// Si on reçoit un tableau de String (cas ou l'on séléectionne une
// nouvelle image)
if (nouvelleDonnees instanceof String[]) {
 
// le tableau de String contient les id des mots clés associés à
// l'image
// on coche les mots clés contenu dans le tableau
tableauMotsClesEnCours = (String[]) nouvelleDonnees;
cocherMotsCles(tableauMotsClesEnCours);
}
// reception d'un nouvel identifiant de mot clé
if(nouvelleDonnees instanceof Integer) {
if(cheminTemporaireAjout != null) {
String id = ((Integer)(nouvelleDonnees)).toString();
TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
String[] userObj = {noeudEnAjout.getText(), id};
noeudEnAjout.setUserObject(userObj);
noeudEnAjout.setId(id);
cheminTemporaireAjout = null;
}
}
arbreMotsCles.enable();
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/vues/BarrePaginationVue.java
New file
0,0 → 1,488
package org.tela_botanica.client.vues;
 
 
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Template;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
 
/**
* Barre de pagination asynchrone avec filtrage des touches et accès directs et
* séquentiels à une page
*
* @author aurelien
*
*/
public class BarrePaginationVue extends Toolbar implements Rafraichissable {
 
/**
* Instance du médiateur à qui on notifie les évnènements
*/
private ListePaginable listePaginable = null;
 
/**
* Bouton précédent
*/
private ToolbarButton prevPage = new ToolbarButton();
/**
* Bouton suivant
*/
private ToolbarButton suivPage = new ToolbarButton();
/**
* Numéro de la page courante (attention, commence à zéro pour des raisons
* pratiques)
*/
private int pageCourante = 0;
/**
* Nombre de page total
*/
private int pageTotale = 1;
/**
* Nombre d'élements total
*/
private int nbElement = 0;
/**
* Nombre d'élément par page
*/
private int taillePage = 0;
/**
* Texte statique de la toolbar 1
*/
private ToolbarTextItem page = new ToolbarTextItem("Page ");
/**
* Affichage de la page courante
*/
private TextField champPage = new TextField("" + (pageCourante + 1));
/**
* Affichage de "sur pageTotale "
*/
private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "
+ pageTotale);
/**
* Texte statique de la toolbar 2
*/
private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ");
/**
* Combobox permettant de selectionner le nombre d'élements à afficher par
* page et donc de changer la variable taillePage
*/
private ComboBox selecteurTaillePage = new ComboBox();
/**
* Les différents intervalles de page possibles (intialisé par défaut)
*/
String[] pages = { "200","100","50", "20", "10" };
Store storeIntervalle = null ;
 
/**
* Label indiquant le type d'element affiché
*
*/
 
private String labelElement="Elements";
 
/**
* taille de la page par defaut
*
*/
 
private int taillePageDefaut = 50;
 
/**
* Texte statique de la toolbar 3
*/
private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
labelElement + " par page ");
/**
* Affiche l'intervalle des éléments contenus dans la page
*/
private ToolbarTextItem intervalleElements = new ToolbarTextItem(labelElement + " "
+ pageCourante * taillePage + " sur " + nbElement);
 
 
/**
* retourne la liste associé à la barre
*/
public ListePaginable getlistePaginable() {
return listePaginable;
}
 
/***************************************************************************
* constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarrePaginationVue() {
super();
}
 
/**
* constructeur avec paramètres
*
* @param im
* le médiateur à associer à la barre
*/
public BarrePaginationVue(ListePaginable lst) {
super();
 
listePaginable = lst;
 
// on remplit l'espace pour que l'intervalle d'élement se place à droite
// de la barre
addItem(intervalleElements);
addSpacer();
// on remplit l'espace pour que l'intervalle d'élement se place à droite
// de la barre
addFill();
// on dispose un peu de texte et quelques espaces pour séparer les
// éléments
addButton(prevPage);
addSpacer();
addItem(page);
addField(champPage);
addItem(surTotalPage);
addSpacer();
addButton(suivPage);
 
champPage.setWidth(30);
 
addSpacer();
addItem(afficherNbElem);
 
prevPage.setIcon("page_prev.png");
suivPage.setIcon("page_suiv.png");
 
setIntervallesPages(pages) ;
 
// le template definit ce que l'on affiche pour chaque element du store
// dans la combobox
final Template tp = new Template("<div class=\"x-combo-list-item\">"
+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
tp.compile();
 
selecteurTaillePage.setTpl(tp);
selecteurTaillePage.setStore(storeIntervalle);
selecteurTaillePage.setEditable(false);
addField(selecteurTaillePage);
selecteurTaillePage.setValue(""+taillePageDefaut);
selecteurTaillePage.setWidth(50);
addItem(nbElemParPage);
 
// on ajoute les différents listeners
ajouterListeners();
}
 
/**
* Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
* @param label
*/
public void setLabelElement(String label) {
this.labelElement = label;
nbElemParPage.setText(labelElement + " par page ");
intervalleElements.setText(labelElement + " " + pageCourante * taillePage + " sur " + nbElement);
}
 
public void setTaillePageParDefaut(int taille) {
this.taillePageDefaut = taille;
selecteurTaillePage.setValue(""+taillePageDefaut);
}
public void setIntervallesPages(String[] intervalle)
{
String[][] intervallesPages = new String[intervalle.length][1] ;
for(int i = 0 ; i < intervalle.length ; i++)
{
intervallesPages[i][0] = intervalle[i] ;
}
storeIntervalle = new SimpleStore(new String[] { "nb_page" },
intervallesPages );
storeIntervalle.load();
selecteurTaillePage.setStore(storeIntervalle);
}
/**
* ajoute les différents listeners nécessaires au bon fonctionnement des
* éléments de la barre de pagination
*/
private void ajouterListeners() {
 
// boutons suivants et précédents
prevPage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
 
// si la page courante n'est pas la première
if (pageCourante > 0) {
// on décrémente la page courante de 1
pageCourante--;
// on rafraichit l'affichage
rafraichirNumeroPage();
// et on notifie le médiateur de l'évenement
listePaginable.changerNumeroPage(pageCourante);
 
}
}
});
 
suivPage.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
 
// si la page courante n'est pas la dernière
if (pageCourante < pageTotale - 1) {
// on incrémente la page courante de 1
pageCourante++;
// on rafraichit l'affichage
rafraichirNumeroPage();
// et on notifie le médiateur de l'évenement
listePaginable.changerNumeroPage(pageCourante);
 
}
}
});
 
champPage.addListener(new TextFieldListenerAdapter() {
 
@Override
public void onSpecialKey(Field field, EventObject e) {
 
// on teste si la touche entrée a été pressée
if (e.getKey() == EventObject.ENTER) {
int nouvellePage = pageCourante;
// on teste avec parseInt si la valeur entrée est un entier
try {
nouvellePage = Integer
.parseInt(champPage.getRawValue());
}
// si ce n'est pas le cas alors on remet le numéro de page
// correct
catch (NumberFormatException nfe) {
rafraichirNumeroPage();
champPage.focus(true);
return;
}
 
// si la conversion reussit on verifie s'il est nécessaire
// de changer de page
// et si la nouvelle est comprise dans l'intervalle des
// pages existantes (0..pageTotale)
if (nouvellePage != pageCourante + 1 && nouvellePage > 0
&& nouvellePage <= pageTotale) {
// le cas échéant, on charge la nouvelle page et on
// notifie le médiateur
changerPageCourante(nouvellePage - 1);
listePaginable.changerNumeroPage(pageCourante);
 
} else {
// sinon on reaffiche l'ancien numero de page sans rien
// changer
rafraichirNumeroPage();
champPage.focus(true);
}
}
}
 
@Override
public void onFocus(Field field) {
 
champPage.focus(true);
}
 
});
 
// pour éviter de se compliquer la vie, on filtre tous les charactères
// non numériques
champPage.addKeyPressListener(new EventCallback() {
 
@Override
public void execute(EventObject e) {
 
// si c'est un numerique
if (Character.isDigit((char) e.getCharCode())) {
// on laisse passer
return;
}
 
// si c'est la touche entrée ou backspace (valider ou effacer)
if (e.getKey() == EventObject.ENTER
|| e.getKey() == EventObject.BACKSPACE) {
// on laisse passer
return;
} else {
// sinon on remet le numero de page correct et on annule
// l'évenement
rafraichirNumeroPage();
e.stopEvent();
}
}
 
});
 
// listener pour la selection dans la combobox
selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
 
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
 
String nouvelleTaillePageString = comboBox.getStore()
.getRecordAt(index).getAsString("nb_page");
int nouvelleTaillePage = Integer
.parseInt(nouvelleTaillePageString);
 
// si la taille de page est différente de l'ancienne
if (nouvelleTaillePage != taillePage) {
// on la change
changerTaillePage(nouvelleTaillePage);
}
// et on met la valeur à jour dans la combobox
comboBox.setValue(nouvelleTaillePageString);
}
 
});
}
 
/**
* Met à jour les affichage sur les numéros de pages et d'intervalle
* d'éléments à partir des variables de classes
*/
public void rafraichirNumeroPage() {
surTotalPage.setText(" sur " + pageTotale);
 
if (nbElement == 0) {
champPage.setValue("" + (0));
// on met simplement à jour l'intervalle qui contient toujours le
// même nombre d'éléments
intervalleElements.setText(labelElement + " 0 - 0 sur 0");
} else {
champPage.setValue("" + (pageCourante + 1));
 
// si la page n'est pas la dernière
if (pageCourante + 1 != pageTotale) {
// sauf pour la dernière page qui contient souvent moins
// d'élements que le nombre d'élements par page
intervalleElements.setText(labelElement + " " + pageCourante
* taillePage + " - " + (pageCourante + 1) * taillePage
+ " sur " + nbElement);
} else {
// on met simplement à jour l'intervalle qui contient toujours
// le même nombre d'éléments
intervalleElements.setText(labelElement + " " + pageCourante
* taillePage + " - " + nbElement + " sur " + nbElement);
}
}
}
 
/**
* Met à jour la page en cours
*
* @param nouvellePageCourante
* la nouvelle page en cours
*/
public void changerPageCourante(int nouvellePageCourante) {
pageCourante = nouvellePageCourante;
}
 
/**
* Methode héritée de l'interface rafraichissable
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on reçoit un tableau de int
if (nouvelleDonnees instanceof int[]) {
int[] page = (int[]) nouvelleDonnees;
// le premier élement est le nombre de pages totales
pageTotale = page[0];
// le second la page en cours
pageCourante = page[1];
// le troisième la taille de la page
taillePage = page[2];
// et le dernier le nombre total d'éléments
nbElement = page[3];
 
// si la page courante dépasse la page totale (cas normalement
// improbable car géré en amont)
// on met le numéro de page à la page courante -1 (car la page
// courante est comptée à partir
// de zéro)
if (pageCourante >= pageTotale && pageCourante != 0) {
pageCourante = pageTotale - 1;
// le cas échéant on en notifie le médiateur
listePaginable.changerNumeroPage(pageCourante);
}
}
 
// enfin on rafraichit les informations affichées à partir des nouvelles
// variables de classes mises à jour
rafraichirNumeroPage();
}
 
/**
* Renvoie les différents intervalles de pages possibles
*
* @return un tableau de string qui contient les différentes
* taille de pages
*/
public String[] getNbPages() {
 
return pages;
}
 
/**
* Envoie au médiateur une demande pour modifier la taille de la page (qui
* va à son tour faire les modifications nécessaires)
*
* @param nouvelleTaillePage
* la nouvelle taille de page (élement appartenant au tableau
* renvoyé par getNbPages())
*/
public void changerTaillePage(int nouvelleTaillePage) {
 
listePaginable.changerTaillePage(nouvelleTaillePage);
 
}
 
/**
* Selectionne la valeur correspond à celle passée en paramètre dans la
* combobox (si elle existe)
*
* @param nouvelleTaillePage
* la nouvelle taille de page
*/
public void selectionnerTaillePage(int nouvelleTaillePage) {
 
selecteurTaillePage.setValue("" + nouvelleTaillePage);
}
 
}
Property changes:
Added: svn:mergeinfo
/branches/v2.8-houe/src/org/tela_botanica/client/vues/MenuAideVue.java
New file
0,0 → 1,94
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
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;
 
public class MenuAideVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour l'aide
*/
private Item aide = null;
 
private Item bugRemarque = null ;
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuAideVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuAideVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
// on construit le menu
aide = new Item("Aide");
bugRemarque = new Item("Bugs, remarques") ;
addItem(aide);
addItem(bugRemarque) ;
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
@Override
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'aide
if (item.equals(aide)) {
// on notifie le médiateur
getIMediateur().afficherAide();
}
// si c'est la soumission de bug ou de remarques
if (item.equals(bugRemarque)) {
getIMediateur().soumettreBugRemarque() ;
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/Rafraichissable.java
New file
0,0 → 1,29
package org.tela_botanica.client.interfaces;
 
/**
* Toutes les classes qui recoivent des données de manières asynchrones ou
* imprévisible implémentent cette interface. Elle permet de faire transiter le
* rafraichissable jusqu'au DAO et d'appeler sa méthode rafraichir un fois les
* données reçues, tout celà en préservant bien la séparation des rôles car les
* classes qui font transiter le rafraichissable ne connaissent que cette
* interface et pas le reste de l'objet
*
* @author aurelien
*
*/
public interface Rafraichissable {
 
/**
* Méthode de mise à jour d'un objet
*
* @param nouvelleDonnees
* Un objet de n'importe quel type (programmation générique) qui
* contient les données de mise à jour
* @param repandreRaffraichissement
* indique si l'élement doit notifier d'autres éléments de sa
* mise à jour
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement);
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/ListePaginable.java
New file
0,0 → 1,15
package org.tela_botanica.client.interfaces;
 
/**
* Toutes les classes qui affichent des listes paginables
* implémentent cette interface.
* @author david delon
*
*/
public interface ListePaginable {
public void changerTaillePage(int nouvelleTaillePage);
public void changerNumeroPage(int pageCourante);
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/Filtrable.java
New file
0,0 → 1,48
package org.tela_botanica.client.interfaces;
 
/**
* Les classes qui implémentent cette interface fonctionnent sous forme de
* filtres et doivent être capable de rendre compte de leur état (modifié ou
* non) et de renvoyer les valeurs de filtrage
*
* @author aurelien
*
*/
public interface Filtrable {
 
/**
* Renvoie un tableau contenant le nom du filtre et sa valeur
*
* @return un tableau contenant le nom du filtre (exemple :
* "ci_meta_mots_cle") et sa valeur
*/
public String[] renvoyerValeursAFiltrer();
 
/**
* Renvoie le nom du filtre de manière lisible (exemple : Filtre pour les
* mots clés)
*
* @return le nom du filtre
*/
public String renvoyerNomFiltre();
 
/**
* Renvoie l'état du filtre (modifié ou non)
*
* @return true si le filtre à été modifié depuis le dernier appel, false
* sinon
*/
public boolean renvoyerEtatFiltre();
 
/**
* Rassemble les valeurs contenant dans le ou les champs du filtre, les
* vérifie, et si celles-ci on changées, appelle le médiateur
*/
public void valider();
/**
* Vide le filtre en cours
*/
public void viderFiltre();
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/iRetourUtilisateur.java
New file
0,0 → 1,8
package org.tela_botanica.client.interfaces;
 
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
public interface iRetourUtilisateur {
 
public void onRetour(Utilisateur utilisateur);
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/FournisseurListe.java
New file
0,0 → 1,17
package org.tela_botanica.client.interfaces;
 
/**
* Toutes les classes qui recoivent des données de manières asynchrones ou imprévisible
* implémentent cette interface.
* Elle permet de faire transiter le rafraichissable jusqu'au DAO et d'appeler sa méthode rafraichir un fois
* les données reçues, tout celà en préservant bien la séparation des rôles car les classes qui font transiter
* le rafraichissable ne connaissent que cette interface et pas le reste de l'objet
* @author aurelien
*
*/
public interface FournisseurListe {
public void obtenirListeDonnees(final Rafraichissable r, String critere);
public void obtenirListeDonnees(Rafraichissable r, String referentiel, String critere);
 
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/iRetourObservation.java
New file
0,0 → 1,8
package org.tela_botanica.client.interfaces;
 
import org.tela_botanica.client.modeles.objets.Observation;
 
public interface iRetourObservation {
 
public void onRetour(Observation observation);
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/iMediateur.java
New file
0,0 → 1,10
package org.tela_botanica.client.interfaces;
 
/*
* Interface Mediateur
*
*/
 
public interface iMediateur {
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/IRetourImage.java
New file
0,0 → 1,9
package org.tela_botanica.client.interfaces;
 
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
 
public interface IRetourImage {
 
public void onRetour(ListeImageCarnet listeImage);
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/IdVue.java
New file
0,0 → 1,94
package org.tela_botanica.client.interfaces;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
 
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
 
public class IdVue extends Window implements Rafraichissable {
 
private ImageMediateur iMediateur;
private TextField champId = null;
private Button ok = null;
 
public IdVue(ImageMediateur im) {
super("Identification");
 
iMediateur = im;
 
champId = new TextField();
ok = new Button("OK");
 
add(champId);
add(ok);
 
setSize(156, 75);
setClosable(false);
setModal(true);
this.setCloseAction(HIDE);
 
ajouterListeners();
}
 
private void ajouterListeners() {
 
// gestion du clic sur le bouton
ok.addListener(new ButtonListenerAdapter() {
 
@Override
public void onClick(Button button, EventObject e) {
 
valider();
}
 
});
 
// gestion de la touche entrée
champId.addKeyListener(EventObject.ENTER, new KeyListener() {
 
@Override
public void onKey(int key, EventObject e) {
 
valider();
}
 
});
 
this.addListener(new WindowListenerAdapter() {
 
@Override
public void onClose(Panel panel) {
 
}
 
});
 
}
 
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
protected void valider() {
 
String id = champId.getText();
getIMediateur().setIdentifiant("" + id.hashCode());
getIMediateur().changerUtilisateur();
this.close();
 
}
 
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/interfaces/VueListable.java
New file
0,0 → 1,21
package org.tela_botanica.client.interfaces;
 
/**
* Les classes qui implétement cette interface sont des classes qui affichent
* des éléments qui peuvent être identifiés de manière unique Cette interface
* facilite le travail du médiateur dans la mesure ou il peut obtenir les
* éléments selectionnés d'une vue sans se préoccuper de son type précis
*
* @author aurelien
*
*/
public interface VueListable {
 
/**
* Renvoie un tableau contenant les identifiants des élements selectionnés
*
* @return les id des éléments sélectionnés
*/
public String[] getIdSelectionnees();
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/CarnetEnLigneModele.java
New file
0,0 → 1,62
package org.tela_botanica.client;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ListeUtilisateurAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.UtilisateurAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
 
/**
* Modele generique permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
* Ne previent pas les vues. Est appelle par le mediateur qui traite le resultat.
*/
public class CarnetEnLigneModele {
 
/**
* booleen qui verifie l'unicite de l'instance
*/
private static boolean estInstancie = false ;
/**
* La configuration en cours
*/
private Configuration config = null;
 
/**
* Constructeur
*/
public static CarnetEnLigneModele Instance()
{
//TODO: voir si ca sert encore à quelque chose
if(!estInstancie)
{
estInstancie = true ;
return new CarnetEnLigneModele() ;
}
else
{
return null ;
}
}
 
public void deconnecterUtilisateur(Rafraichissable r, String user) {
new UtilisateurAsynchroneDAO(this).deconnecterUtilisateur(r,user );
}
 
public void connecterUtilisateur(Rafraichissable r, String login , String password) {
new UtilisateurAsynchroneDAO(this).connecteUtilisateur(r,login, password );
}
 
public void getEtatUtilisateur(Rafraichissable r) {
new UtilisateurAsynchroneDAO(this).getEtatUtilisateur(r);
}
 
public void obtenirListeUtilisateur(Rafraichissable r,String rech, String identifiant) {
ListeUtilisateurAsynchroneDAO liDAO = new ListeUtilisateurAsynchroneDAO(this);
liDAO.obtenirListeUtilisateur(r,rech,identifiant);
}
 
public void accepterLicenceUtilisateur(String identifiantUtilisateur) {
UtilisateurAsynchroneDAO utilisateurDao = new UtilisateurAsynchroneDAO(this);
utilisateurDao.accepterLicence(identifiantUtilisateur);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/cel2.java
New file
0,0 → 1,102
package org.tela_botanica.client;
 
import org.tela_botanica.client.modeles.objets.Configuration;
 
import com.google.gwt.ajaxloader.client.AjaxLoader;
import com.google.gwt.ajaxloader.client.AjaxLoader.AjaxLoaderOptions;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.Ext;
import com.gwtext.client.widgets.Viewport;
 
/**
* Entry point classes define <code>onModuleLoad()</code>.
*/
public class cel2 implements EntryPoint {
 
/**
* This is the entry point method.
*/
@Override
public void onModuleLoad() {
/*
// A décommenter + compiler en detailed dans le cas d'une erreur
// survernant uniquement sur le serveur
GWT.setUncaughtExceptionHandler(null);
GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
@Override
public void onUncaughtException(Throwable e) {
Window.alert("uncaught: " + e.getMessage());
String s = buildStackTrace(e, "RuntimeException:\n");
Window.alert(s);
e.printStackTrace();
}
});
*/
// TODO: config devrait être un singleton
Configuration config = new Configuration();
// Chargement de l'api google maps v3 avant l'initialisation pour
// éviter des "complications"
// TODO: fabriquer une classe qui cherche dans la config une liste d'api
// à charger, les instancie et ensuite lance l'application
AjaxLoaderOptions optAj = AjaxLoaderOptions.newInstance();
optAj.setOtherParms("key="+Configuration.getCleGoogleMaps()+"&sensor=false");
Runnable callback = new Runnable() {
public void run() {
initialiserCel();
};
};
AjaxLoader.loadApi("maps", "3", callback, optAj);
}
private void initialiserCel() {
CarnetEnLigneMediateur carnetEnLigneMediateur= CarnetEnLigneMediateur.Instance();
new Viewport(carnetEnLigneMediateur.getPanneauPrincipalCarnetEnLigne()) ;
carnetEnLigneMediateur.getEtatUtilisateur() ;
 
Timer t = new Timer() {
@Override
public void run() {
Ext.get("loading").hide();
}
};
t.schedule(3000);
}
/*private String buildStackTrace(Throwable t, String log) {
if (t != null) {
log += t.getClass().toString();
log += t.getMessage();
//
StackTraceElement[] stackTrace = t.getStackTrace();
if (stackTrace != null) {
StringBuffer trace = new StringBuffer();
for (int i = 0; i < stackTrace.length; i++) {
trace.append(stackTrace[i].getClassName() + "." + stackTrace[i].getMethodName() + "("
+ stackTrace[i].getFileName() + ":" + stackTrace[i].getLineNumber());
}
log += trace.toString();
}
//
Throwable cause = t.getCause();
if (cause != null && cause != t) {
log += buildStackTrace(cause, "CausedBy:\n");
}
}
return log;
}*/
public static native void LogVersFirebug(Object o) /*-{
if (!!($wnd.console && $wnd.console.log)) {
console.log(o);
}
}-*/;
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/EntiteGeographiqueObservation.java
New file
0,0 → 1,74
package org.tela_botanica.client.modeles.objets;
 
/**
*
* Classe representant une idZoneGeo geographique (localite, zoneGeo, lieu dit) presente dans la liste des observations
*
*/
 
public class EntiteGeographiqueObservation {
 
 
private String idZoneGeo=null;
private String zoneGeo=null;
private String lieuDit=null;
private String station=null;
private String lat=null;
private String lon=null;
 
public EntiteGeographiqueObservation() {
}
 
/**
* @param zoneGeo
* @param departement
*/
public EntiteGeographiqueObservation(String idZoneGeo, String zoneGeo, String lieuDit, String station) {
this.idZoneGeo = idZoneGeo;
this.zoneGeo = zoneGeo;
this.lieuDit = lieuDit;
this.station = station;
}
public void setLat(String la) {
lat = la;
}
public void setLon(String lo) {
lon = lo;
}
 
public String getLat() {
return lat;
}
public String getLon() {
return lon;
}
 
public String getIdZoneGeo() {
return idZoneGeo;
}
 
 
public String getZoneGeo() {
return zoneGeo;
}
 
 
public String getLieuDit() {
return lieuDit;
}
public String getStation() {
return station;
}
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeEntiteGeographiqueObservation.java
New file
0,0 → 1,54
package org.tela_botanica.client.modeles.objets;
 
 
import java.util.LinkedHashMap;
 
/**
* table de hachage composée d'entite geographique, renvoyé par les objets de type DAO
* La clé est le nom de l'entite + le nom de l'entite parente
*
* @author david delon
*
*/
public class ListeEntiteGeographiqueObservation extends LinkedHashMap<String, EntiteGeographiqueObservation> {
private static final long serialVersionUID = 2717710270773281540L;
/**
* Constructeur sans paramètres
*/
public ListeEntiteGeographiqueObservation()
{
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeEntiteGeographiqueObservation(int taille)
{
super(taille);
}
/**
* Constructeur avec paramètre
* @param ic un tableau d'ImageCarnet
*/
public ListeEntiteGeographiqueObservation(EntiteGeographiqueObservation[] ent)
{
super() ;
for (int i = 0; i < ent.length; i++)
{
if(ent[i] != null && ent[i] instanceof EntiteGeographiqueObservation)
{
this.put(ent[i].hashCode()+"",ent[i]);
}
}
}
public void put(EntiteGeographiqueObservation value) {
this.put(value.hashCode()+"",value);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/Configuration.java
New file
0,0 → 1,304
package org.tela_botanica.client.modeles.objets;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
import com.google.gwt.i18n.client.Dictionary;
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.Window;
import com.google.gwt.user.client.Window.Location;
 
/**
* Classe chargeant certains paramètres de configuration à partir d'un fichier
* javascript (config.js)
*
* @author aurelien
*
*/
public class Configuration {
 
/**
* L'url de base du serveur jrest
*/
private static String serviceBaseUrl;
 
private static String imageBaseUrl;
private static String suiviBugUrl ;
private static String aideBaseUrl ;
 
private static String remarquesBaseUrl ;
private static String emailContact;
private static String referentielGeo ;
private static String cleGoogleMaps ;
 
private static String lienEfloreBaseUrl;
private static String refTax;
private static String refTaxVersion;
private static String licence ="";
private static String formatOriginal = "";
private static String formatZoom = "";
private static String formatGalerie = "";
private static String formatListe = "";
 
private static String utiliseRedirectionImage;
 
private static String imageRedirectUrl;
private static String tailleMaxUpload;
private static List<InfosReferentielNom> referentielsDispos;
private static String activerSaisieChampsEtendus = "0";
private static String wikiDescriptionChampsEtendusPageUrl = "";
private static String wikiDescriptionChampsEtendusRestUrl = "";
private static String wikiDescriptionChampsEtendusRestUrlOptions = "";
private static String wikiDescriptionChampsEtendusUrlOptionsPageTpl = "";
 
/**
* Constructeur sans argument
*/
public Configuration() {
// on utilise le dictionnaire d'internationalisation pour lire les
// variables du fichier javascript
//if(GWT.isScript()) {
serviceBaseUrl = Dictionary.getDictionary("configuration").get(
"serviceBaseUrl");
emailContact = Dictionary.getDictionary("configuration").get(
"emailContact");
suiviBugUrl = Dictionary.getDictionary("configuration").get(
"suiviBugUrl");
imageBaseUrl = Dictionary.getDictionary("configuration").get(
"imageBaseUrl");
aideBaseUrl = Dictionary.getDictionary("configuration").get(
"aideBaseUrl");
remarquesBaseUrl = Dictionary.getDictionary("configuration").get(
"remarquesBaseUrl");
referentielGeo = Dictionary.getDictionary("configuration").get(
"referentielGeo");
cleGoogleMaps = Dictionary.getDictionary("configuration").get(
"cleGoogleMaps");
lienEfloreBaseUrl = Dictionary.getDictionary("configuration").get(
"lienEfloreBaseUrl");
formatOriginal = Dictionary.getDictionary("configuration").get(
"formatOriginal");
formatZoom = Dictionary.getDictionary("configuration").get(
"formatZoom");
formatGalerie = Dictionary.getDictionary("configuration").get(
"formatGalerie");
formatListe = Dictionary.getDictionary("configuration").get(
"formatListe");
utiliseRedirectionImage = Dictionary.getDictionary("configuration").get(
"utiliseRedirectionImage");
imageRedirectUrl = Dictionary.getDictionary("configuration").get(
"imageRedirectUrl");
tailleMaxUpload = Dictionary.getDictionary("configuration").get(
"tailleMaxUpload");
referentielsDispos = parserReferentielsDispos(Dictionary.getDictionary("configuration").get(
"referentielsDispos"));
activerSaisieChampsEtendus = Dictionary.getDictionary("configuration").get(
"activerSaisieChampsEtendus");
wikiDescriptionChampsEtendusPageUrl = Dictionary.getDictionary("configuration").get(
"wikiDescriptionChampsEtendusPageUrl");
wikiDescriptionChampsEtendusRestUrl = Dictionary.getDictionary("configuration").get(
"wikiDescriptionChampsEtendusRestUrl");
wikiDescriptionChampsEtendusRestUrlOptions = Dictionary.getDictionary("configuration").get(
"wikiDescriptionChampsEtendusRestUrlOptions");
wikiDescriptionChampsEtendusUrlOptionsPageTpl = Dictionary.getDictionary("configuration").get(
"wikiDescriptionChampsEtendusUrlOptionsPageTpl");
// Pour test, l'activation de l'ajout des champs étendus est activable ou désactivable par
// l'url
if(Location.getParameter("activerSaisieChampsEtendus") != null) {
if(Location.getParameter("activerSaisieChampsEtendus").equals("1")) {
activerSaisieChampsEtendus = "1";
} else if(Location.getParameter("activerSaisieChampsEtendus").equals("0")) {
activerSaisieChampsEtendus = "0";
}
}
}
private List<InfosReferentielNom> parserReferentielsDispos(String chaineListeReferentiels) {
String[] tabReferentiels = chaineListeReferentiels.split(";");
List<InfosReferentielNom> referentiels = new ArrayList<InfosReferentielNom>(tabReferentiels.length);
for (int i = 0; i < tabReferentiels.length; i++) {
InfosReferentielNom infoRef = new InfosReferentielNom(tabReferentiels[i]);
referentiels.add(infoRef);
}
return referentiels;
}
 
/**
* Accesseur pour l'url de base du serveur jrest
*
* @return une url de la forme http://emplacement_serveur/jrest
*/
public static String getServiceBaseUrl() {
return serviceBaseUrl;
}
/**
* Accesseur pour l'url de base du suivi de bug
*
* @return une url pointant vers le suivi des bugs
*/
public static String getSuiviBugUrl() {
return suiviBugUrl;
}
/**
* Accesseur pour l'url de base des images
*
* @return une url pointant vers la racine du dossier contenant les images
*/
public static String getImageBaseUrl() {
return imageBaseUrl ;
}
/**
* Accesseur pour l'url de base de l'aide
*
* @return une url pointant vers la racine de l'aide
*/
public static String getAideBaseUrl() {
return aideBaseUrl ;
}
/**
* Accesseur pour l'url de base du widget de remarques
*
* @return une url pointant vers la racine du widget (sans paramètres)
*/
public static String getRemarquesBaseUrl() {
return remarquesBaseUrl;
}
/**
* Accesseur pour l'email de contact du carnet en ligne
*
* @return une chaine contenant l'email de contact
*/
public static String getEmailContact() {
return emailContact;
}
/**
* Accesseur pour le référentiel geo
*
* @return le référentiel geo
*/
public static String getReferentielGeo() {
return referentielGeo ;
}
/**
* Accesseur pour la clé google maps
*
* @return la clé google maps
*/
public static String getCleGoogleMaps() {
return cleGoogleMaps ;
}
 
public static String getLienEfloreBaseUrl() {
return lienEfloreBaseUrl;
}
public static String getLicence() {
return licence;
}
public static String getFormatOriginal() {
return formatOriginal;
}
public static String getFormatZoom() {
return formatZoom;
}
public static String getFormatGalerie() {
return formatGalerie;
}
public static String getFormatListe() {
return formatListe;
}
 
public static boolean utiliseRedirectionImages() {
return utiliseRedirectionImage.equals("1");
}
 
public static String getImageRedirectUrl() {
return imageRedirectUrl;
}
public static String getTailleMaxUpload() {
return tailleMaxUpload;
}
public static List<InfosReferentielNom> getReferentielsDispos() {
return referentielsDispos;
}
public static boolean saisieChampsEtendusActivee() {
return activerSaisieChampsEtendus.equals("1");
}
public static String getWikiDescriptionChampsEtendusPageUrl() {
return wikiDescriptionChampsEtendusPageUrl;
}
public static String getWikiDescriptionChampsEtendusRestUrl() {
return wikiDescriptionChampsEtendusRestUrl;
}
public static String getWikiDescriptionChampsEtendusUrlOptions() {
return wikiDescriptionChampsEtendusRestUrlOptions;
}
public static String getWikiDescriptionChampsEtendusUrlOptionsPageTpl() {
return wikiDescriptionChampsEtendusUrlOptionsPageTpl;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeGroupesChampsEtendus.java
New file
0,0 → 1,51
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.cel2;
 
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;
 
public class ListeGroupesChampsEtendus extends HashMap<String,HashMap<String, String>> {
public HashMap<String, String> correspondancesClesLabels ;
public ListeGroupesChampsEtendus(String groupeChampsEtendusJson) {
super();
try {
correspondancesClesLabels = new HashMap<String, String>();
JSONValue groupesJson = JSONParser.parseStrict(groupeChampsEtendusJson);
JSONArray groupes = groupesJson.isArray();
for (int i = 0; i < groupes.size(); i++) {
JSONObject groupe = groupes.get(i).isObject();
String nomGroupe = groupe.get("nom").isString().stringValue();
JSONArray listeClesLabels = groupe.get("champs").isArray();
HashMap<String, String> groupesClesLabel = new HashMap<String, String>();
for (int j = 0; j < listeClesLabels.size(); j++) {
JSONObject champ = listeClesLabels.get(j).isObject();
String cle = champ.get("cle").isString().stringValue();
String label = champ.get("label").isString().stringValue();
groupesClesLabel.put(cle, label);
correspondancesClesLabels.put(cle, label);
}
this.put(nomGroupe, groupesClesLabel);
}
} catch (Exception e) {
// TODO: handle exception
}
}
public HashMap<String, String> getCorrespondancesClesLabel() {
return correspondancesClesLabels;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/Utilisateur.java
New file
0,0 → 1,129
package org.tela_botanica.client.modeles.objets;
 
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONString;
 
public class Utilisateur {
 
private String loginUtilisateurConnecte = null;
private String loginUtilisateurConsulte = null;
private String identifiantUtilisateurConnecte = null;
private String identifiantUtilisateurConsulte = null;
private boolean identifie = false;
private boolean isAdmin = false;
private boolean licenceAcceptee = false;
private static Utilisateur thisUtilisateur = null;
public static Utilisateur InitialiserInstance(JSONObject objetJsonUtilisateur) {
thisUtilisateur = new Utilisateur(objetJsonUtilisateur);
return thisUtilisateur;
}
public static Utilisateur getInstance() {
return thisUtilisateur;
}
private Utilisateur(JSONObject objetJsonUtilisateur) {
// login utilisateur ou vide si non identifie
loginUtilisateurConnecte = ((JSONString) objetJsonUtilisateur.get("courriel")).stringValue();
loginUtilisateurConsulte = loginUtilisateurConnecte;
// identifiant utilisateur ou bien identifiant de session si non identifie
identifiantUtilisateurConnecte = ((JSONString) objetJsonUtilisateur.get("id_utilisateur")).stringValue();
identifiantUtilisateurConsulte = identifiantUtilisateurConnecte;
// Drapeau leve si utilisateur deja identifie
identifie = objetJsonUtilisateur.get("connecte").isBoolean().booleanValue();
// Drapeau leve si utilisateur est admin
isAdmin = objetJsonUtilisateur.get("admin").isBoolean().booleanValue();
// Drapeau leve si utilisateur a accepte licence
licenceAcceptee = objetJsonUtilisateur.get("licence_acceptee").isBoolean().booleanValue();
}
/**
* Retourne vrai si utilisateur identifie
* @return boolean
*/
public boolean isIdentifie() {
return identifie;
}
/**
* Retourne vrai si utilisateur est admin
* @return boolean
*/
public boolean isAdmin() {
return isAdmin;
}
/**
* Met à jour l'identité utilisée (dans le cas où l'utilisateur est admin)
* @param identite la nouvelle identité
*/
public void setUtilisateurConsulte(String identifiantUtilisateurConsulte, String loginUtilisateurConsulte) {
if(isAdmin()) {
this.identifiantUtilisateurConsulte = identifiantUtilisateurConsulte;
this.loginUtilisateurConsulte = loginUtilisateurConsulte;
}
else {
this.identifiantUtilisateurConsulte = identifiantUtilisateurConnecte;
this.loginUtilisateurConsulte = loginUtilisateurConnecte;
}
}
/**
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session
* @return String identifiantUtilisateurConsulte
*/
public String getIdentifiantUtilisateurConnecte() {
return identifiantUtilisateurConnecte;
}
/**
* Retourne l'identifiant de l'utilisateur consulte
* @return String identifiantUtilisateurConsulte
*/
public String getIdentifiantUtilisateurConsulte() {
return identifiantUtilisateurConsulte;
}
/**
* Retourne le login de l'utilisateur identifie ou un identifiant de session
* @return String loginUtilisateurConnecte
*/
public String getLoginUtilisateurConnecte() {
return loginUtilisateurConnecte;
}
/**
* Retourne le login de l'utilisateur consulte
* @return String loginUtilisateurConsulte
*/
public String getLoginUtilisateurConsulte() {
return loginUtilisateurConsulte;
}
public void setLicenceAcceptee(boolean licenceAcceptee) {
this.licenceAcceptee = licenceAcceptee;
}
public boolean getLicenceAcceptee() {
return licenceAcceptee;
}
public void setLoginUtilisateurConnecte(String loginUtilisateurConnecte) {
this.loginUtilisateurConnecte = loginUtilisateurConnecte;
}
public void setLoginUtilisateurConsulte(String loginUtilisateurConsulte) {
this.loginUtilisateurConsulte = loginUtilisateurConsulte;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/InfosReferentielNom.java
New file
0,0 → 1,66
package org.tela_botanica.client.modeles.objets;
 
public class InfosReferentielNom {
private String code = null;
private String version = null;
private String versionCourte = null;
private String intitule = null;
 
public InfosReferentielNom(String infosReferentiel) {
String[] codeCompletIntitule = infosReferentiel.split(",");
intitule = codeCompletIntitule[1];
String[] codeVersion = codeCompletIntitule[0].split(":");
code = codeVersion[0];
if(codeVersion.length > 1) {
version = codeVersion[1];
versionCourte = formaterVersionCourte(version);
} else {
version = versionCourte = null;
}
}
public InfosReferentielNom(String code, String version, String intitule) {
super();
this.code = code;
this.version = version;
this.intitule = intitule;
this.versionCourte = formaterVersionCourte(version);
}
private String formaterVersionCourte(String version) {
return version.replaceAll("v","");
}
public String getCodeVersionComplet() {
return code+":"+version;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getIntitule() {
return intitule;
}
public void setIntitule(String intitule) {
this.intitule = intitule;
}
 
public String getVersionCourte() {
return versionCourte;
}
 
public void setVersionCourte(String versionCourte) {
this.versionCourte = versionCourte;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ReferentielNom.java
New file
0,0 → 1,45
package org.tela_botanica.client.modeles.objets;
 
 
/**
*
* Classe representant un element du referentiel de nom
*
*/
public class ReferentielNom {
 
 
private String nom=null;
private String numeroNom=null;
private String statut=null;
public ReferentielNom() {
}
 
/**
* @param nom
* @param numeroNom
* @param statut
*
*/
public ReferentielNom(String nom, String numeroNom, String statut) {
this.nom = nom;
this.numeroNom = numeroNom;
this.statut = statut;
}
 
 
public String getNom() {
return nom;
}
 
public String getNumeroNom() {
return numeroNom;
}
 
public String getStatut() {
return statut;
}
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeDate.java
New file
0,0 → 1,59
package org.tela_botanica.client.modeles.objets;
 
 
import java.util.LinkedHashMap;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONString;
 
/**
* table de hachage composée d'entite geographique, renvoyé par les objets de type DAO
* La clé est le nom de l'entite + le nom de l'entite parente
*
* @author david delon
*
*/
public class ListeDate extends LinkedHashMap<String, DateObservation> {
/**
*
*/
private static final long serialVersionUID = 6057292016502553510L;
 
/**
* Constructeur sans paramètres
*/
public ListeDate()
{
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeDate(int taille)
{
super(taille);
}
public ListeDate(JSONArray dates)
{
super(dates.size()) ;
final int taillemax = dates.size();
for (int i = 0; i < taillemax; i++) {
JSONString dateEncours = dates.get(i).isString() ;
if(dateEncours != null)
{
String dateString = dateEncours.stringValue() ;
DateObservation dat = new DateObservation(dateString);
 
this.put(dateString,dat);
}
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeReferentielPerso.java
New file
0,0 → 1,76
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
 
public class ListeReferentielPerso extends HashMap<String, String> {
public static enum TypesReferentiels {
REFERENTIEL_LIEU_DIT {
@Override
public String toString() {
return "lieudit";
}
},
REFERENTIEL_STATION {
@Override
public String toString() {
return "station";
}
},
REFERENTIEL_MILIEU {
@Override
public String toString() {
return "milieu";
}
}
}
/**
*
*/
private static final long serialVersionUID = 2159394354752556196L;
private TypesReferentiels typeReferentiel = null;
 
/**
* Constructeur sans paramètres
*/
public ListeReferentielPerso(TypesReferentiels typeReferentiel)
{
super();
this.typeReferentiel = typeReferentiel;
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeReferentielPerso(int taille,TypesReferentiels typeReferentiel)
{
super();
this.typeReferentiel = typeReferentiel;
}
/**
* Constructeur avec paramètre
* @param ic un tableau de strings
*/
public ListeReferentielPerso(TypesReferentiels typeReferentiel, String[] nom)
{
super() ;
this.typeReferentiel = typeReferentiel;
for (int i = 0; i < nom.length; i++)
{
if(nom[i] != null && nom[i].equals("00null"))
{
this.put(i+"",nom[i]);
}
}
}
public TypesReferentiels getTypeReferentiel() {
return typeReferentiel;
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeReferentielNom.java
New file
0,0 → 1,52
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
 
/**
* table de hachage composée de noms, renvoyé par les objets de type DAO
* pour les noms
* La clé est l'identifiant du nom dans la base de données, et la valeur un objet
* de type ReferentielNom
* @author david delon
*
*/
public class ListeReferentielNom extends HashMap<String, ReferentielNom> {
private static final long serialVersionUID = 3214510270773281540L;
/**
* Constructeur sans paramètres
*/
public ListeReferentielNom()
{
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeReferentielNom(int taille)
{
super(taille);
}
/**
* Constructeur avec paramètre
* @param ic un tableau d'ImageCarnet
*/
public ListeReferentielNom(ReferentielNom[] nom)
{
super() ;
for (int i = 0; i < nom.length; i++)
{
if(nom[i] != null && nom[i] instanceof ReferentielNom)
{
this.put(nom[i].getNumeroNom(),nom[i]);
}
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ImageCarnet.java
New file
0,0 → 1,457
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
 
import org.tela_botanica.client.i18n.VocabulaireMetadonnees;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.xml.client.Document;
import com.google.gwt.xml.client.Node;
import com.google.gwt.xml.client.NodeList;
import com.google.gwt.xml.client.Text;
import com.google.gwt.xml.client.XMLParser;
import com.google.gwt.xml.client.impl.DOMParseException;
 
/**
*
* Classe representant une image du carnet, elle ne contient pas d'image à
* proprement parler mais plutôt les informations associées ainsi que l'url
* distante. C'est une table de hachage qui contient des paires propriété/valeur
*
*/
public class ImageCarnet extends HashMap<String, String> {
 
/**
*
*/
private static final long serialVersionUID = -6220175386957259859L;
 
/**
* Constructeur avec un objet JSON
*
* @param image
*/
public ImageCarnet(JSONObject image) {
// l'objet JSON est une table de hachage
Set<String> im = image.keySet();
 
// on la parcourt pour chaque clé
for (Iterator<String> iterator = im.iterator(); iterator.hasNext();) {
 
// si elle est associée à une valeur, on l'ajoute
String key = iterator.next();
if (Util.jsonNonNull(image, key)) {
String valeur = image.get(key).isString().stringValue();
this.put(key, valeur);
} else {
// sinon on ajoute la clé avec une valeur vide
String valeur = " ";
this.put(key, valeur);
}
 
}
 
}
public ImageCarnet(String[][] image) {
 
for (int i = 0; i < image.length; i++) {
if (image[i][0] != null && image[i][1] != null) {
this.put(image[i][0], image[i][1]);
}
}
}
 
/**
* Surcharge de toString qui affiche toutes les propriétés de l'image
*/
 
@Override
public String toString() {
String valeur = " ";
 
for (Iterator<String> iterator = this.keySet().iterator(); iterator
.hasNext();) {
 
String key = iterator.next();
if (this.get(key) != null) {
valeur += "cle : " + key + " valeur :" + this.get(key) + "\n";
}
 
}
 
return valeur;
}
 
/**
* Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
* cette fonction qui retire les charactères nuls qui font planter
* l'affichage, il ne faut pas utiliser get directement
*
* @param cle
* @return la valeur associée à la clé
*/
public String renvoyerValeurCorrecte(String cle) {
if (this.containsKey((cle))) {
String valeur = this.get(cle);
if (valeur.equals("null") || valeur == null) {
return " ";
} else {
char nullChar = '\u0000';
String sNull = "" + nullChar;
valeur = valeur.replaceAll(sNull, "");
return valeur;
}
} else {
return " ";
}
}
 
/**
* Acesseur pour l'id de l'image
*
* @return l'id de l'image
*/
public String getId() {
 
return renvoyerValeurCorrecte("id_image");
}
 
/**
* Acesseur pour le numero d'ordre de l'image
*
* @return l'ordre de l'image
*/
public String getOrdre() {
 
return renvoyerValeurCorrecte("ordre");
}
 
/**
* Base de l'url serveur pour les images
*
* @return url racine pour les images
*/
public String getVraieBaseUrl() {
return Configuration.getImageBaseUrl() ;
}
/**
* Base de l'url serveur pour les images
*
* @return url racine pour les images
*/
public String getBaseUrlRedirect() {
return Configuration.getImageRedirectUrl() ;
}
public String getIdAvecPadding() {
String id = getId();
 
int maxZeros = 9 - id.length();
 
for (int i = 0; i < maxZeros; i++) {
id = "0" + id;
}
return id;
}
private String getUrlFormat(String format) {
String urlImage = "";
if(Configuration.utiliseRedirectionImages()) {
String identifiantRedirect = getIdAvecPadding()+format;
urlImage = getBaseUrlRedirect()+identifiantRedirect;
} else {
urlImage = getVraieUrlFormat(format);
}
 
return urlImage;
}
 
/**
* Renvoie le nom de base du fichier image et ses sous dossier
*
* @return le nom de base du fichier de type (XXX_XXX_XXX), et ses sous
* dossier
*/
public String[] getVraiCheminBaseFichier() {
String id = getIdAvecPadding();
 
String dossierNv1 = id.substring(0, 3);
String dossierNv2 = id.substring(3, 6);
String fichierNv = id.substring(6, 9);
 
String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv;
 
String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 };
return infosFichier;
}
private String getVraieUrlFormat(String format) {
String[] infosFichier = getVraiCheminBaseFichier();
 
return getVraieBaseUrl() + infosFichier[1] + "/" + infosFichier[2] + "/"+format+"/"
+ infosFichier[0] + "_"+format+".jpg";
}
/**
* Renvoie le chemin et nom du fichier format original
*
* @return le chemin du fichier grand original
*/
public String getUrlFormatOriginal() {
 
return getUrlFormat(Configuration.getFormatOriginal());
}
 
/**
* Renvoie le chemin et nom du fichier grand format
*
* @return le chemin du fichier grand format
*/
public String getUrlFormatZoom() {
 
return getUrlFormat(Configuration.getFormatZoom());
}
 
/**
* Renvoie le chemin et nom du fichier petit format
*
* @return le chemin du fichier petit format
*/
public String getUrlFormatGalerie() {
 
return getUrlFormat(Configuration.getFormatGalerie());
}
 
/**
* Renvoie le chemin et nom du fichier moyen format
*
* @return le chemin du fichier moyen format
*/
public String getUrlFormatListe() {
 
return getUrlFormat(Configuration.getFormatListe());
}
 
/**
* Renvoie la taille de l'image
*
* @return un tableau de deux string contenant la hauteur puis la largeur
*/
public String[] getTailleImage() {
String[] XY = { renvoyerValeurCorrecte("hauteur"),
renvoyerValeurCorrecte("largeur") };
return XY;
}
 
public String[] getNote() {
String[] note = { renvoyerValeurCorrecte("note_qualite") };
return note;
}
 
/**
* Renvoie la date exif associée à l'image
*
* @return la date associée à l'image
*/
public String getDate() {
 
if(renvoyerValeurCorrecte("date_prise_de_vue").equals("00/00/0000"))
{
return "" ;
}
return renvoyerValeurCorrecte("date_prise_de_vue");
}
 
/**
* Renvoie la ville associée à l'image
*
* @return la ville iptc
*/
public Object getIptcCity() {
 
return renvoyerValeurCorrecte("");
}
 
/**
* Renvoie le fabricant de l'appareil
*
* @return le fabricant
*/
public String getFabriquantAppareil() {
 
return renvoyerValeurCorrecte("appareil_fabricant");
}
 
/**
* Renvoie le modele de l'appareil
*
* @return le modele
*/
public String getModeleAppareil() {
 
return renvoyerValeurCorrecte("appareil_modele");
}
 
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Iptc
*
* @return les métadonnées iptc
*/
public String[][] getMetadonnesIptc() {
return getMetadonneesXml("meta_iptc");
}
 
/**
* Renvoie un tableau nom / valeur de toutes les metadonnées Exif
*
* @return les métadonnées Exif
*/
public String[][] getMetadonnesExif() {
return getMetadonneesXml("meta_exif");
}
private String[][] getMetadonneesXml(String type) {
String[][] metadonnees = {{},{}};
String xml = renvoyerValeurCorrecte(type);
String invalidXmlPattern = "[^"
+ "\\u0009\\u000A\\u000D"
+ "\\u0020-\\uD7FF"
+ "\\uE000-\\uFFFD"
+ "\\u10000-\\u10FFFF"
+ "]+";
xml = xml.replaceAll(invalidXmlPattern, " ");
 
try {
Document d = XMLParser.parse(xml);
if(d.hasChildNodes()) {
NodeList attributs = d.getFirstChild().getChildNodes();
int taille = attributs.getLength();
metadonnees = new String[taille][2];
for(int i = 0; i < taille; i++) {
if(attributs.item(i) != null) {
XMLParser.removeWhitespace(attributs.item(i));
attributs.item(i).normalize();
String nomMetaDonneestraduite = VocabulaireMetadonnees.getTraduction(attributs.item(i).getNodeName());
metadonnees[i][0] = nomMetaDonneestraduite;
if(attributs.item(i).hasChildNodes()) {
Node valeur = attributs.item(i).getFirstChild();
if(valeur.getNodeType() == Node.TEXT_NODE) {
metadonnees[i][1] = ((Text)valeur).getData();
} else {
metadonnees[i][1] = "";
}
}
}
}
}
} catch(DOMParseException e) {
}
return metadonnees;
}
 
/**
* Renvoie un tableau nom / valeur contenant les infos générales
*
* @return les infos générales
*/
public String[][] getInfoGenerales() {
 
String[][] metaGen = new String[2][2];
 
metaGen[0][0] = "commentaire";
metaGen[0][1] = this.renvoyerValeurCorrecte("commentaire");
 
metaGen[1][0] = "date_prise_de_vue";
metaGen[1][1] = this.renvoyerValeurCorrecte("date_prise_de_vue");
 
return metaGen;
}
 
/**
* Renvoie une string contenant les mots clés séparés par des ','
*
* @return les mots clés
*/
public String getMotsCles() {
 
return renvoyerValeurCorrecte("mots_cles");
}
 
/**
* Met à jour le commenentaire et la date
*
* @param commentaires
* le nouveau commentaire
* @param date
* la nouvelle date
*/
public void miseAJourInfoGenerales(String commentaires, String date,
String note) {
put("commentaire", commentaires);
put("note_qualite", note);
put("date_prise_de_vue", date);
}
 
/**
* Met à jour les mots clés
*
* @param motsClesEnCours
* la liste de mots clés séparés par des ','
*/
public void mettreAjourMotsCles(String motsClesEnCours) {
 
put("mots_cles", motsClesEnCours);
 
}
public void mettreAjourObsAssociees(String idsObsAssociees) {
put("id_observation", idsObsAssociees);
}
/**
* Accesseur pour le nom original
*
* @return le nom orginal de l'image
*/
public String getNomOriginal() {
return renvoyerValeurCorrecte("nom_original");
}
public String getIdsObsAssociees() {
String observationsAssociees = renvoyerValeurCorrecte("id_observation");
observationsAssociees = observationsAssociees.replaceAll("null", "");
return observationsAssociees;
}
public String[][] obtenirChampsModifiablesImage() {
String[][] champs = {
{"commentaire", renvoyerValeurCorrecte("commentaire")},
{"note_qualite", renvoyerValeurCorrecte("note_qualite")},
{"date_prise_de_vue",renvoyerValeurCorrecte("date_prise_de_vue")}
};
return champs;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeImageCarnet.java
New file
0,0 → 1,54
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
 
/**
* table de hachage composée d'ImageCarnet, renvoyé par les objets de type DAO
* pour les images. La clé est l'identifiant de l'image dans la base de données,
* et la valeur un objet de type ImageCarnet. GWT ne supporte pas encore les
* type paramètres mais quand il le fera il faudra créer la HashMap avec
* <String,ImageCarnet>
*
* @author aurelien
*
*/
public class ListeImageCarnet extends HashMap<String, ImageCarnet> {
 
/**
*
*/
private static final long serialVersionUID = 2715320270773281540L;
 
/**
* Constructeur sans paramètres
*/
public ListeImageCarnet() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param taille
* la taille de la table de hachage
*/
public ListeImageCarnet(int taille) {
super(taille);
}
 
/**
* Constructeur avec paramètre
*
* @param ic
* un tableau d'ImageCarnet
*/
public ListeImageCarnet(ImageCarnet[] ic) {
super();
for (int i = 0; i < ic.length; i++) {
if (ic[i] != null && ic[i] instanceof ImageCarnet) {
this.put(ic[i].getOrdre(), ic[i]);
}
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/Ontologies.java
New file
0,0 → 1,148
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
 
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
 
public class Ontologies {
//TODO: extraire toutes ces valeurs dans des fichiers de configuration
// ou bien via l'appel d'un web service spécialisé.
private static HashMap<String, String> valeursCertitude = null;
private static List<InfosReferentielNom> listeReferentielsNoms = null;
 
public static Store getValeursCertitude() {
Object[][] valeurs = {{"Certaine","certain"},
{"Douteuse","douteux"},
{"A déterminer","aDeterminer"}
};
SimpleStore storeCertitude = new SimpleStore(new String[] {"label","valeur"},valeurs);
storeCertitude.load();
return storeCertitude;
}
public static Store getValeursAbondance() {
Object[][] valeurs = {
{"5 : recouvrement R > 75%","5"},
{"4 : 50% < R < 75%","4"},
{"3 : 25% < R < 50%","3"},
{"2 : 5% < R < 25%","2"},
{"1 : 1% < R < 5%","1"},
{"+ : recouvrement R < 1%","+"},
{"r : rare (quelques pieds)","r"},
{"i : un seul individu","i"},
{"1-5 individus","1-5"},
{"5-10 individus","5-10"},
{"10-50 individus","10-50"},
{"50-100 individus","50-100"},
{"100-500 individus","100-500"},
{">500 individus",">500"},
{"E : exceptionnel","E"},
{"RR : très rare","RR"},
{"R : rare","R"},
{"AR : assez rare","AR"},
{"PC : peu commun","PC"},
{"AC : assez commun","AC"},
{"C : commun","C"},
{"CC : très commun","CC"}
};
SimpleStore storeAbondance = new SimpleStore(new String[] {"label","valeur"},valeurs);
storeAbondance.load();
return storeAbondance;
}
public static String getCorrespondanceCertitude(String cle) {
if(valeursCertitude == null) {
valeursCertitude = new HashMap<String, String>();
valeursCertitude.put("certain", "Certaine");
valeursCertitude.put("douteux", "Douteuse");
valeursCertitude.put("aDeterminer", "A déterminer");
}
 
String valeur = valeursCertitude.get(cle);
return valeur == null ? cle : valeur;
}
public static Store getValeursReferentiel() {
List<InfosReferentielNom> listeReferentiels = Configuration.getReferentielsDispos();
Object[][] valeurs = new Object[listeReferentiels.size()][2];
int i = 0;
for (Iterator<InfosReferentielNom> iterator = listeReferentiels.iterator(); iterator
.hasNext();) {
InfosReferentielNom infosReferentielNom = iterator.next();
String[] valeur = {infosReferentielNom.getIntitule(), infosReferentielNom.getCode()};
valeurs[i] = valeur;
i++;
}
SimpleStore storeReferentiels = new SimpleStore(new String[] {"label","valeur"},valeurs);
storeReferentiels.load();
return storeReferentiels;
}
 
public static InfosReferentielNom getInfosReferentielNomParCode(String code) {
InfosReferentielNom infos = null;
List<InfosReferentielNom> listeReferentiels = Configuration.getReferentielsDispos();
for (Iterator<InfosReferentielNom> iterator = listeReferentiels.iterator(); iterator
.hasNext();) {
InfosReferentielNom infosReferentielNom = iterator.next();
if(infosReferentielNom.getCode().equals(code)) {
infos = infosReferentielNom;
break;
}
}
return infos;
}
public static Store getValeursPhenologie() {
Object[][] valeurs = {
{"00-09: germination, développement des bourgeons", "00-09"},
{"10-19: développement des feuilles", "10-19"},
{"11: par ex, environ 10% des feuilles épanouies", "11"},
{"15: par ex, environ 50% des feuilles épanouies", "15"},
{"20-29: formation de pousses latérales, tallage", "20-29"},
{"30-39: développement des tiges, croissance des rosettes", "30-39"},
{"40-49: développement des organes de propagation végétative", "40-49"},
{"50-59: apparition de l'inflorescence, épiaison", "50-59"},
{"60-69: floraison", "60-69"},
{"61 : par ex, environ 10% des fleurs épanouies", "61"},
{"65 : par ex, environ 50% des fleurs épanouies", "65"},
{"70-79: fructification", "70-79"},
{"80-89: maturité des fruits et des graines", "80-89"},
{"85: par ex, 50% des fruits matures", "85"},
{"90-99: sénescence et dormance", "90-99"},
{"91: par ex, environ 10% des feuilles jaunes", "91"},
{"95: par ex, environ 50% des feuilles jaunes", "95"}
};
SimpleStore storeAbondance = new SimpleStore(new String[] {"label","valeur"},valeurs);
storeAbondance.load();
return storeAbondance;
}
public static HashMap<String, String> getCorrespondanceGrilleObservationChampsTri() {
HashMap<String, String> correspondances = new HashMap<String, String>();
correspondances.put("etat_observation", "transmission");
correspondances.put("referentiel_taxo_observation", "nom_referentiel");
correspondances.put("nomSaisi_observation", "nom_sel");
correspondances.put("certitude", "certitude");
correspondances.put("nomRetenu_observation", "nom_ret");
correspondances.put("famille_observation", "famille");
correspondances.put("abondance", "abondance");
correspondances.put("phenologie", "phenologie");
correspondances.put("etat_observation", "transmission");
correspondances.put("lieu_observation", "ce_zone_geo");
correspondances.put("altitude_observation", "altitude");
correspondances.put("date_observation", "date_observation");
correspondances.put("ordre_observation", "ordre");
return correspondances;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ReferentielCommune.java
New file
0,0 → 1,48
package org.tela_botanica.client.modeles.objets;
 
/**
*
* Classe representant un element du referentiel commune ou localite
*
*/
 
public class ReferentielCommune {
 
 
private String commune=null;
private String departement=null;
private String codeInsee=null;
public ReferentielCommune() {
}
 
/**
* @param commune
* @param departement
*/
public ReferentielCommune(String commune, String code) {
this.commune = commune;
if(code.length() == 5) {
codeInsee = code;
departement = code.substring(0,2);
} else {
departement = code;
}
}
 
public String getCommune() {
return commune;
}
 
 
public String getDepartement() {
return departement;
}
 
public String getCodeInsee() {
return codeInsee;
}
 
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/DateObservation.java
New file
0,0 → 1,43
package org.tela_botanica.client.modeles.objets;
 
/**
*
* Classe representant une entite geographique (localite, commune, lieu dit) presente dans la liste des observations
*
*/
 
public class DateObservation {
private String annee=null;
private String mois=null;
private String jour=null;
/**
* @param commune
* @param departement
*/
public DateObservation(String date) {
String dateTab[] = date.split(" ") ;
String dateSpl[] = dateTab[0].split("-") ;
annee= dateSpl[0];
mois= dateSpl[1];
jour= dateSpl[2];
}
 
public String getAnnee() {
return annee;
}
 
 
public String getMois() {
return mois;
}
 
 
public String getJour() {
return jour;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeReferentielCommune.java
New file
0,0 → 1,53
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
 
/**
* table de hachage composée de communes, renvoyé par les objets de type DAO
* pour les communes
* TODO : utiliser un identifiant commune
* La clé est le nom de la commune + l'identifiant du departement de la commune dans la base de données, et la valeur un objet
* de type ReferentielCommune
* @author david delon
*
*/
public class ListeReferentielCommune extends HashMap<String, ReferentielCommune> {
private static final long serialVersionUID = 2714510270773281540L;
/**
* Constructeur sans paramètres
*/
public ListeReferentielCommune()
{
super();
}
/**
* Constructeur avec paramètre
* @param taille la taille de la table de hachage
*/
public ListeReferentielCommune(int taille)
{
super(taille);
}
/**
* Constructeur avec paramètre
* @param ic un tableau d'ImageCarnet
*/
public ListeReferentielCommune(ReferentielCommune[] com)
{
super() ;
for (int i = 0; i < com.length; i++)
{
if(com[i] != null && com[i] instanceof ReferentielCommune)
{
this.put(com[i].getCommune()+com[i].getDepartement(),com[i]);
}
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/Observation.java
New file
0,0 → 1,392
package org.tela_botanica.client.modeles.objets;
 
import java.util.Map;
 
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.json.client.JSONObject;
 
 
public class Observation {
 
private String id=null;
private String transmis=null;
private String nomSaisi=null;
private String nomRetenu=null;
private String numeroNomenclaturalSaisi=null;
private String numeroNomenclaturalRetenu=null;
private String numeroTaxonomique=null;
private String famille=null;
private String localite=null;
private String identifiantLocalite=null;
private String lieudit=null;
private String station=null;
private String milieu=null;
private String commentaire=null;
private String date=null;
private String numeroOrdre=null;
private String motsCles=null;
private String latitude=null;
private String longitude=null;
private String referentielGeo=null;
private String referentielTaxo=null;
private String abondance=null;
private String certitude=null;
private String phenologie=null;
private String altitude=null;
private Map<String, ChampEtendu> champsEtendus=null;
 
public Observation() {
}
 
/**
* Une observation telle que stockee dans la base de donnee
*
* @param transmis
* @param nomSaisi
* @param nomRetenu
* @param numeroNomenclaturalSaisi
* @param numeroNomenclaturalRetenu
* @param numeroTaxonomique
* @param famille
* @param localite
* @param IdentifiantLocalite
* @param lieudit
* @param station
* @param milieu
* @param commentaire
* @param date
* @param numeroOrdre
*/
public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclaturalSaisi, String numeroNomenclaturalRetenu, String numeroTaxonomique, String famille, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) {
this.transmis = transmis;
this.nomSaisi = nomSaisi;
this.nomRetenu = nomRetenu;
this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi;
this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu;
this.numeroTaxonomique = numeroTaxonomique;
this.famille = famille;
this.identifiantLocalite = identifiantLocalite;
this.lieudit = lieudit;
this.station = station;
this.milieu = milieu;
this.commentaire = commentaire;
this.date = date;
this.numeroOrdre = numeroOrdre;
// Suppresion indication departementale (on pourrait faire mieux !!)
if(localite != null) {
int pos=localite.indexOf(" (" );
if (pos>=0) {
this.localite=localite.substring(0,pos);
}
else {
this.localite=localite;
}
}
this.motsCles = "";
}
public Observation(JSONObject observation) {
this.transmis = Util.getValeurJsonOuVide(observation, "transmission");
this.identifiantLocalite = Util.getValeurJsonOuVide(observation, "ce_zone_geo");
this.nomSaisi = Util.getValeurJsonOuVide(observation, "nom_sel");
this.nomRetenu = (Util.getValeurJsonOuVide(observation,"nom_ret"));
this.numeroNomenclaturalSaisi = Util.getValeurJsonOuVide(observation,"nom_sel_nn");
this.numeroNomenclaturalRetenu = Util.getValeurJsonOuVide(observation,"nom_ret_nn");
this.numeroTaxonomique= Util.getValeurJsonOuVide(observation,"nt");
this.famille = Util.getValeurJsonOuVide(observation,"famille");
this.localite = Util.getValeurJsonOuVide(observation,"zone_geo");
this.lieudit = Util.getValeurJsonOuVide(observation,"lieudit");
this.station= Util.getValeurJsonOuVide(observation,"station");
this.milieu = Util.getValeurJsonOuVide(observation,"milieu");
this.commentaire = Util.getValeurJsonOuVide(observation,"commentaire");
this.date = Util.getValeurJsonOuVide(observation,"date_observation");
this.numeroOrdre = Util.getValeurJsonOuVide(observation,"ordre");
this.id = Util.getValeurJsonOuVide(observation,"id_observation");
this.latitude = Util.getValeurJsonOuVide(observation,"latitude");
this.longitude = Util.getValeurJsonOuVide(observation,"longitude");
this.altitude = Util.getValeurJsonOuVide(observation,"altitude");
this.motsCles = Util.getValeurJsonOuVide(observation,"mots_cles");
this.abondance = Util.getValeurJsonOuVide(observation,"abondance");
this.certitude = Util.getValeurJsonOuVide(observation,"certitude");
this.phenologie = Util.getValeurJsonOuVide(observation,"phenologie");
this.setReferentielTaxo(Util.getValeurJsonOuVide(observation,"nom_referentiel"));
this.setChampsEtendus(Util.getMapValeursOuVide(observation, "obs_etendue"));
}
/**
* Une observation saisie ou modifiee
*
* @param nomSaisi
* @param numeroNomenclaturalSaisi
* @param localite
* @param IdentifiantLocalite
* @param lieudit
* @param station
* @param milieu
* @param commentaire
* @param date
*
*/
public Observation(String nomSaisi, String numeroNomenclaturalSaisi, String localite, String identifiantLocalite, String lieudit, String station, String milieu, String commentaire, String date) {
this.nomSaisi = nomSaisi;
this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi;
this.identifiantLocalite = identifiantLocalite;
this.lieudit = lieudit;
this.station = station;
this.milieu = milieu;
this.commentaire = commentaire;
this.date = date;
// Suppresion indication departementale (on pourrait faire mieux !!)
if(localite != null) {
int pos=localite.indexOf(" (" );
if (pos>=0) {
this.localite=localite.substring(0,pos);
}
else {
this.localite=localite;
}
}
this.motsCles = "" ;
}
 
 
public String getNomSaisi() {
return nomSaisi;
}
 
 
public String getNumeroOrdre() {
return numeroOrdre;
}
 
 
public String getCommentaire() {
return commentaire;
}
 
 
public String getDate() {
return date;
}
 
 
public String getFamille() {
return famille;
}
 
 
public String getLieudit() {
return lieudit;
}
 
 
public String getLocalite() {
return localite;
}
 
 
public String getIdentifiantLocalite() {
if(identifiantLocalite != null) {
identifiantLocalite = identifiantLocalite.replaceAll("\"", "");
}
return identifiantLocalite;
}
 
public String getMilieu() {
return milieu;
}
 
 
public String getNomRetenu() {
return nomRetenu;
}
 
 
public String getNumeroNomenclaturalSaisi() {
return numeroNomenclaturalSaisi;
}
 
 
public String getNumeroNomenclaturalRetenu() {
return numeroNomenclaturalRetenu;
}
 
 
public String getNumeroTaxonomique() {
return numeroTaxonomique;
}
 
public void setNomRetenu(String nomRetenu) {
this.nomRetenu = nomRetenu;
}
 
public void setNumeroNomenclaturalSaisi(String numeroNomenclaturalSaisi) {
this.numeroNomenclaturalSaisi = numeroNomenclaturalSaisi;
}
 
public void setNumeroNomenclaturalRetenu(String numeroNomenclaturalRetenu) {
this.numeroNomenclaturalRetenu = numeroNomenclaturalRetenu;
}
 
public void setNumeroTaxonomique(String numeroTaxonomique) {
this.numeroTaxonomique = numeroTaxonomique;
}
 
public String getStation() {
return station;
}
 
 
public String getTransmis() {
return transmis;
}
public String getMotsCles() {
return motsCles;
}
public String getLatitude() {
return this.latitude ;
}
public String getLongitude() {
return this.longitude ;
}
public String getReferentielGeo() {
return this.referentielGeo ;
}
public String getId() {
return this.id;
}
public String getAbondance() {
return this.abondance;
}
public String getCertitude() {
return this.certitude;
}
public void setMotsCles(String motsCles) {
this.motsCles = motsCles;
}
public void setNumeroOrdre(String numeroOrdre) {
this.numeroOrdre = numeroOrdre;
}
public void setLatitude(String latitude) {
this.latitude = latitude;
}
public void setLongitude(String longitude) {
this.longitude = longitude;
}
public void setReferentielGeo(String refGeo) {
this.referentielGeo = refGeo;
}
 
public void setId(String id) {
this.id = id;
}
public void setAbondance(String abondance) {
this.abondance = abondance;
}
public void setCertitude(String certitude) {
this.certitude = certitude;
}
 
public String getReferentielTaxo() {
return referentielTaxo;
}
 
public String getCodeCourtReferentielTaxo() {
String codeRef = "";
if(!getReferentielTaxo().equals("") && getReferentielTaxo().length() >= 3) {
int positionDeuxPoints = referentielTaxo.indexOf(':');
if (positionDeuxPoints == -1) {
codeRef = referentielTaxo;
} else {
codeRef = referentielTaxo.substring(0, positionDeuxPoints);
}
}
return codeRef;
}
 
public void setReferentielTaxo(String referentielTaxo) {
this.referentielTaxo = referentielTaxo;
}
public String getPhenologie() {
return phenologie;
}
public void setPhenologie(String phenologie) {
this.phenologie = phenologie;
}
 
public String getAltitude() {
return altitude;
}
 
 
public void setAltitude(String altitude) {
this.altitude = altitude;
}
 
 
public void setValeurChampEtendu(String cle, String valeur, String label) {
ChampEtendu champ = new ChampEtendu(cle, label, valeur);
champsEtendus.put(cle, champ);
}
public ChampEtendu getChampEtendu(String cle) {
ChampEtendu champ = null;
if(champsEtendus.containsKey(cle)) {
champ = champsEtendus.get(cle);
}
return champ;
}
public String getLabelChampEtendu(String cle) {
String valeur = "";
if(champsEtendus.containsKey(cle)) {
valeur = champsEtendus.get(cle).getLabel();
}
return valeur;
}
 
public String getValeurChampEtendu(String cle) {
String valeur = "";
if(champsEtendus.containsKey(cle)) {
valeur = champsEtendus.get(cle).getValeur();
}
return valeur;
}
public Map<String, ChampEtendu> getChampsEtendus() {
return champsEtendus;
}
 
public void setChampsEtendus(Map<String, ChampEtendu> champsEtendus) {
this.champsEtendus = champsEtendus;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeObservation.java
New file
0,0 → 1,60
package org.tela_botanica.client.modeles.objets;
 
import java.util.LinkedHashMap;
 
/**
* table de hachage composée d'observation, renvoyé par les objets de type DAO
* pour les images. La clé est l'identifiant de l'observation dans la base de
* données, et la valeur un objet de type Observation
*
* L'uitilisation de LinkedHashMap permet de conserver l'ordre d'insertion des
* elements à la lecture
*
* @author david delon
*
*/
public class ListeObservation extends LinkedHashMap<String, Observation> {
/**
*
*/
private static final long serialVersionUID = 2715320270773281540L;
 
/*
* Constructeur sans paramètres
*/
public ListeObservation() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param taille
* la taille de la table de hachage
*/
public ListeObservation(int taille) {
super(taille);
}
 
/**
* Constructeur avec paramètre
*
* @param ic
* un tableau d'ImageCarnet
*/
public ListeObservation(Observation[] obs) {
super();
for (int i = 0; i < obs.length; i++) {
if (obs[i] != null && obs[i] instanceof Observation) {
this.put(obs[i].getNumeroOrdre(), obs[i]);
}
}
}
 
public void ajouterObservation(Observation obs) {
if (obs != null) {
this.put(obs.getNumeroOrdre(), obs);
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ChampEtendu.java
New file
0,0 → 1,42
package org.tela_botanica.client.modeles.objets;
 
public class ChampEtendu {
 
private String cle;
private String label;
private String valeur;
public ChampEtendu() {
}
public ChampEtendu(String cle, String label, String valeur) {
this.setCle(cle);
this.setLabel(label);
this.setValeur(valeur);
}
 
public String getCle() {
return cle;
}
 
public void setCle(String cle) {
this.cle = cle;
}
 
public String getLabel() {
return label;
}
 
public void setLabel(String label) {
this.label = label;
}
 
public String getValeur() {
return valeur;
}
 
public void setValeur(String valeur) {
this.valeur = valeur;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/objets/ListeChampsEtendus.java
New file
0,0 → 1,30
package org.tela_botanica.client.modeles.objets;
 
import java.util.HashMap;
import java.util.Iterator;
 
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.Window;
 
public class ListeChampsEtendus extends HashMap<String, String> {
public ListeChampsEtendus(String listeChampsEtendusJson) {
super();
final JSONValue responseValue = JSONParser.parse(listeChampsEtendusJson);
JSONObject reponse = null;
// si c'est un objet
if ((reponse = responseValue.isObject()) != null) {
Iterator<String> it = reponse.keySet().iterator();
while(it.hasNext()) {
String cle = it.next();
String valeur = reponse.get(cle).isString().stringValue();
this.put(cle, valeur);
}
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeReferentielChampsEtendusDAO.java
New file
0,0 → 1,258
package org.tela_botanica.client.modeles.dao;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.cel2;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeChampsEtendus;
import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.core.client.Callback;
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
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.Window;
 
public class ListeReferentielChampsEtendusDAO {
public static ListeGroupesChampsEtendus cacheGroupes;
public static HashMap<String, String> cacheClesLabels;
public static HashMap<String, String> cacheDescription = new HashMap<String, String>();
public static String prefixePageChampEtendu = "CE";
public ListeReferentielChampsEtendusDAO(ObservationModele obs) {
}
public void obtenirListeNomsChampsEtendus(final Rafraichissable r, String recherche) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
"/NomsChampsEtendus/cle"+
"?recherche="+URL.encode(recherche));
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onResponseReceived(final Request request,
final Response response) {
 
ListeChampsEtendus labelCles = new ListeChampsEtendus(response.getText());
r.rafraichir(labelCles, true);
}
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
public void obtenirListeValeursChampEtendu(final Rafraichissable r, String cle, String recherche) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
"/NomsChampsEtendus/valeur"+
"?cle="+URL.encode(cle)+"&recherche="+URL.encode(recherche));
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onResponseReceived(final Request request,
final Response response) {
 
 
ArrayList<String> valeurs = new ArrayList<String>();
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = null;
if ((reponse = responseValue.isArray()) != null) {
for(int i = 0; i < reponse.size(); i++) {
valeurs.add(reponse.get(i).isString().stringValue());
}
}
r.rafraichir(valeurs, true);
}
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
public void obtenirGroupesChampsEtendus(final Rafraichissable r) {
if(cacheGroupes == null) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
"/CatalogueChampsEtendus/groupes");
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onResponseReceived(final Request request,
final Response response) {
ListeGroupesChampsEtendus valeurs = new ListeGroupesChampsEtendus(response.getText());
cacheGroupes = valeurs;
r.rafraichir(valeurs, true);
}
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
});
} catch (RequestException e) {
e.printStackTrace();
}
} else {
r.rafraichir(cacheGroupes, true);
}
}
public void obtenirCatalogueChampsEtendus(final Rafraichissable r) {
if(cacheClesLabels == null) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
"/CatalogueChampsEtendus/champs");
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onResponseReceived(final Request request,
final Response response) {
try {
JSONValue champsJson = JSONParser.parseStrict(response.getText());
JSONArray champs = champsJson.isArray();
cacheClesLabels = new HashMap<String, String>(champs.size());
for (int i = 0; i < champs.size(); i++) {
JSONObject champ = champs.get(i).isObject();
String cle = champ.get("cle").isString().stringValue();
String label = champ.get("label").isString().stringValue();
cacheClesLabels.put(cle, label);
 
r.rafraichir(cacheClesLabels, true);
}
} catch (Exception e) {
// TODO: handle exception
}
}
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
});
} catch (RequestException e) {
e.printStackTrace();
}
} else {
r.rafraichir(cacheClesLabels, true);
}
}
public static void telechargerDescriptionWikini(final String champ, final Callback<String, String> callback) {
String url = Configuration.getWikiDescriptionChampsEtendusRestUrl()+obtenirNomPageChampEtendu(champ)+"?";
String options = Configuration.getWikiDescriptionChampsEtendusUrlOptions();
 
if(cacheDescription.containsKey(champ)) {
callback.onSuccess(cacheDescription.get(champ));
}
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,
url + options);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
try {
final JSONValue responseValue = JSONParser.parse(response.getText());
String description = "";
JSONObject reponse = responseValue.isObject();
if(reponse != null && reponse.get("texte") != null && reponse.get("texte").isString() != null) {
description = reponse.get("texte").isString().stringValue();
}
cacheDescription.put(champ, description);
callback.onSuccess(description);
} catch(Exception exception) {
this.onError(request, exception);
}
}
 
@Override
public void onError(Request request, Throwable exception) {
cacheDescription.put(champ, "");
callback.onFailure("");
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
// Pour obliger la page wiki a avoir été créée avant de rediriger, on utilise une requete synchrone
private static native String effectuerRequeteSynchrone(String url, String contenu, String typeRequete)/*-{
// tant pis pour les vieux navigateurs, ie6 etc...
// tous ceux que l'on supporte connaissent XMLHttpRequest
var xhReq = new XMLHttpRequest();
xhReq.open(typeRequete, url, false);
if(typeRequete == "POST") xhReq.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
xhReq.send(contenu);
var serverResponse = xhReq.status + xhReq.responseText;
return serverResponse;
}-*/;
public static void creerPageWikini(final String cle) {
String url = Configuration.getWikiDescriptionChampsEtendusRestUrl()+obtenirNomPageChampEtendu(cle)+"?";
String options = Configuration.getWikiDescriptionChampsEtendusUrlOptions();
String pageTpl = Configuration.getWikiDescriptionChampsEtendusUrlOptionsPageTpl();
effectuerRequeteSynchrone(url + options + pageTpl, "", "GET");
}
public static String obtenirUrlEditionDescriptionWiki(String cle) {
String url = Configuration.getWikiDescriptionChampsEtendusPageUrl()+obtenirNomPageChampEtendu(cle)+"/edit";
return url;
}
protected static String obtenirNomPageChampEtendu(String cle) {
return prefixePageChampEtendu+Util.convertirEnChaMot(cle);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/TransmissionObservationAsynchroneDAO.java
New file
0,0 → 1,65
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
 
public class TransmissionObservationAsynchroneDAO {
 
ObservationModele om = null ;
public TransmissionObservationAsynchroneDAO(ObservationModele observationModele) {
om = observationModele ;
}
 
public void transmettreObservations(final Rafraichissable r, String identifiant, String idsObs, boolean publier) {
// on envoie le get asynchrone
String post = "&transmission=";
if(publier) {
post += "1";
}
else
{
post += "0" ;
}
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()
+"/InventoryTransmit/"+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+"/"+idsObs) ;
try {
rb.sendRequest(post, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
r.rafraichir("OK",true);
}
}) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
 
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeEntiteGeographiqueObservationAsynchroneDAO.java
New file
0,0 → 1,122
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation;
import org.tela_botanica.client.observation.ObservationModele;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
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;
 
/**
* DAO la liste des communes.
* @author David Delon
*
*/
public class ListeEntiteGeographiqueObservationAsynchroneDAO {
 
/**
* Le modèle associé au DAO.
*/
private ObservationModele observationModele = null;
/**
* Constructeur.
* @param obs : Modele
*/
public ListeEntiteGeographiqueObservationAsynchroneDAO(final ObservationModele obs) {
this.observationModele = obs;
}
/**
* Envoie une requete au serveur jrest pour obtenir les communes correspondant
* à des critères données en paramètres.
* @param r le rafraichissable qui demande la mise à jour
* @param critere un string contenant le terme a rechercher
*/
public final void obtenirListeEntitesGeographiques(final Rafraichissable r, final String utilisateur) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryLocationList/" + utilisateur);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeEntiteGeographiqueObservation listeEntiteGeographiqueObservation;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = null;
// si c'est un tableau
if ((reponse = responseValue.isArray()) != null) {
JSONObject entites;
final int taillemax = reponse.size();
listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(taillemax);
for (int i = 0; i < taillemax; i++) {
if ((entites = reponse.get(i).isObject()) != null) {
String idZoneGeo = Util.convertirChaineZoneGeoVersDepartement(Util.getValeurJsonOuVide(entites, "ce_zone_geo"));
String zoneGeo = Util.getValeurJsonOuVide(entites, "zone_geo");
String lieuDit = Util.getValeurJsonOuVide(entites, "lieudit");
String station = Util.getValeurJsonOuVide(entites, "station");
EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(idZoneGeo, zoneGeo, lieuDit, station);
listeEntiteGeographiqueObservation.put(ent);
}
}
} else {
listeEntiteGeographiqueObservation = new ListeEntiteGeographiqueObservation(0);
}
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
r.rafraichir(listeEntiteGeographiqueObservation, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ImageGeneriqueVueAsynchroneDAO.java
New file
0,0 → 1,95
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO d'accès a une observation
*
* @author aurelien
*
*/
public class ImageGeneriqueVueAsynchroneDAO {
 
/**
* Le modele associé au DAO
*/
private ObservationModele observationModele = null;
 
public ImageGeneriqueVueAsynchroneDAO(ObservationModele obs) {
observationModele = obs;
}
 
 
 
/**
* Recherche Image associee a un nom
* @param r
* @param identifiant
* @param numeroNomenclaturalSaisiObservation
*/
public void obtenirURLImage(final Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
String referentielDefaut = Configuration.getReferentielsDispos().get(0).getCode();
referentielTaxo = (referentielTaxo != null && !referentielTaxo.isEmpty()) ? referentielTaxo : referentielDefaut;
// on envoie le get asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()
+"/NameImage/"+referentielTaxo+"/"+numeroNomenclaturalSaisiObservation) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
try {
JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse;
String urlImage=null;
String urlImageMax=null;
if ((reponse = responseValue.isArray()) != null) {
// Url Image
urlImage= ((JSONString)reponse.get(0)).stringValue();
urlImageMax= ((JSONString)reponse.get(1)).stringValue();
}
else {
urlImage="";
urlImageMax="";
}
r.rafraichir(new String[]{urlImage,urlImageMax},true);
} catch (Exception e) {
// TODO: handle exception
}
}
}) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ImageInformationRepartitionAsynchroneDAO.java
New file
0,0 → 1,89
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO d'accès a une observation
*
* @author aurelien
*
*/
public class ImageInformationRepartitionAsynchroneDAO {
 
/**
* Le modele associé au DAO
*/
private ObservationModele observationModele = null;
 
public ImageInformationRepartitionAsynchroneDAO(ObservationModele obs) {
observationModele = obs;
}
 
 
 
/**
* Recherche Image repartition associee a un nom
* @param r
* @param identifiant
* @param numeroNomenclaturalSaisiObservation
*/
public void obtenirURLImage(final Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
String referentielDefaut = Configuration.getReferentielsDispos().get(0).getCode();
referentielTaxo = (referentielTaxo != null && !referentielTaxo.isEmpty()) ? referentielTaxo : referentielDefaut;
// on envoie le get asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()
+"/NameMap/"+referentielTaxo+"/"+numeroNomenclaturalSaisiObservation) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse;
String urlImage=null;
 
if ((reponse = responseValue.isArray()) != null) {
// Url Image
urlImage= ((JSONString)reponse.get(0)).stringValue();
}
else {
urlImage="";
}
r.rafraichir(urlImage,true);
}
}) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/UtilisateurAsynchroneDAO.java
New file
0,0 → 1,183
package org.tela_botanica.client.modeles.dao;
 
/**
* Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
*
*/
 
import org.tela_botanica.client.CarnetEnLigneModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
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.Window;
 
public class UtilisateurAsynchroneDAO {
 
/**
* Le modèle associé au DAO
*/
private CarnetEnLigneModele carnetEnLigneModele = null ;
/**
* Constructeur
*/
public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) {
this.carnetEnLigneModele=carnetEnLigneModele;
}
/**
* Methode de classe d'appel du service gestion identification
* @param baseURL : URL du service
* @param retour : methode appelle en retour d'appel
*/
public void getEtatUtilisateur(final Rafraichissable r) {
 
// Recherche identifiant utilisateur identifie
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() + "/User/") ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
if(response.getText().isEmpty()) {
Window.alert("Impossible de contacter le serveur, veuillez vérifier la configuration du cel ou contacter un administrateur");
} else {
JSONValue jsonValue = JSONParser.parse(response.getText());
JSONObject objetJsonUtilisateur;
if ((objetJsonUtilisateur = jsonValue.isObject()) != null) {
Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur);
r.rafraichir(utilisateur,true);
}
}
}
}) ;
} catch (RequestException e) {
}
}
 
 
 
public void deconnecterUtilisateur(final Rafraichissable r, String user) {
 
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()+ "/User/" + user) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
JSONValue jsonValue = JSONParser.parse(response.getText());
JSONObject objetJsonUtilisateur;
if ((objetJsonUtilisateur = jsonValue.isObject()) != null) {
Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur);
r.rafraichir(utilisateur,true);
}
}
}) ;
} catch (RequestException e) {
}
}
 
public void connecteUtilisateur (final Rafraichissable r, String login, String password) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl() + "/User/" + login + "/" + password) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
JSONValue jsonValue = JSONParser.parse(response.getText());
JSONObject objetJsonUtilisateur;
if ((objetJsonUtilisateur = jsonValue.isObject()) != null) {
Utilisateur utilisateur = Utilisateur.InitialiserInstance(objetJsonUtilisateur);
r.rafraichir(utilisateur,true);
}
}
}) ;
} catch (RequestException e) {
e.printStackTrace() ;
}
}
 
public void accepterLicence(String identifiantUtilisateur) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl() + "/LicenceUtilisateur/"+identifiantUtilisateur) ;
try {
String postData = "licence=1";
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
}
}) ;
} catch (RequestException e) {
e.printStackTrace() ;
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeUtilisateurAsynchroneDAO.java
New file
0,0 → 1,74
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.CarnetEnLigneModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
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;
 
public class ListeUtilisateurAsynchroneDAO {
 
CarnetEnLigneModele cModele = null ;
public ListeUtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) {
cModele = carnetEnLigneModele ;
}
public final void obtenirListeUtilisateur(final Rafraichissable r,final String rech, final String utilisateur) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryUserList/" + utilisateur+"/"+rech);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
String[][] util ;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = responseValue.isArray();
if(reponse != null) {
util = new String[reponse.size()][2];
for(int i = 0; i < reponse.size() ; i++) {
JSONObject item = reponse.get(i).isObject();
util[i][0] = Util.getValeurJsonOuVide(item, "id_utilisateur");
util[i][1] = Util.getValeurJsonOuVide(item, "courriel");
}
}
else {
util = new String[0][2];
}
r.rafraichir(util, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesImageAsynchroneDAO.java
New file
0,0 → 1,108
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Window;
 
/**
* DAO d'accès à la liaison entre mots clés et observations
*
* @author aurelien
*
*/
public class LiaisonMotsClesImageAsynchroneDAO {
 
/**
* Le modele associé au DAO
*/
private ImageModele iModele = null;
 
public LiaisonMotsClesImageAsynchroneDAO(ImageModele img) {
iModele = img;
}
 
/**
* Setteur pour le modèle
*
* @param img
* le modèle à associer
*/
public void setiModele(ImageModele img) {
iModele = img;
}
 
/**
* Envoie requete au serveur pour modifier une observations
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
*/
public void modifier(final Rafraichissable r, String utilisateur, String idImg, String idMC) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/") ;
String postData = "ce_utilisateur="+utilisateur
+"&images="+idImg
+"&mots_cles="+URL.encodeComponent(""+idMC);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
Window.alert("Liaison aux mots clés effectuée");
}
}) ;
} catch (RequestException e) {
}
}
 
public void supprimer(final Rafraichissable r, String utilisateur, String idImg, String idMC) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordImageLink/" + utilisateur + "/" +idImg+ "/" + URL.encodeComponent(""+idMC) + "/") ;
String postData = "&action=DELETE";
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
Window.alert("Liaison aux mots clés supprimée");
}
}) ;
} catch (RequestException e) {
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/NomRetenuAsynchroneDAO.java
New file
0,0 → 1,69
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
public class NomRetenuAsynchroneDAO {
 
private ObservationModele oModele = null ;
public NomRetenuAsynchroneDAO(ObservationModele observationModele) {
oModele = observationModele ;
}
 
public void obtenirNomRetenu(final Rafraichissable r, final String anum) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,
Configuration.getServiceBaseUrl()
+ "/name/"+anum);
 
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
JSONValue jsonValue = JSONParser.parse(response.getText());
JSONArray jsonArray;
 
if ((jsonArray = jsonValue.isArray()) != null) {
String aname = ((JSONString) jsonArray.get(0)).toString();
// Nom
if (aname.compareTo("null")!=0) {
String[] numNom = {aname, anum } ;
r.rafraichir(numNom, false);
}
}
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/LiaisonMotsClesObsAsynchroneDAO.java
New file
0,0 → 1,107
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
 
/**
* DAO d'accès à la liaison entre mots clés et observations
*
* @author aurelien
*
*/
public class LiaisonMotsClesObsAsynchroneDAO {
 
/**
* Le modele associé au DAO
*/
private ObservationModele oModele = null;
 
public LiaisonMotsClesObsAsynchroneDAO(ObservationModele obs) {
oModele = obs;
}
 
/**
* Setteur pour le modèle
*
* @param obs
* le modèle à associer
*/
public void setoModele(ObservationModele obs) {
oModele = obs;
}
 
/**
* Envoie requete au serveur pour modifier une observations
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
*/
public void modifier(final Rafraichissable r, String utilisateur, String idObs, String idMC) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/") ;
String postData = "ce_utilisateur="+utilisateur
+"&observations="+idObs
+"&mots_cles="+URL.encodeComponent(""+idMC);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
oModele.obtenirListeObservation(r);
}
}) ;
} catch (RequestException e) {
}
}
 
public void supprimer(final Rafraichissable r, String utilisateur, String idObs, String idMC) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryKeyWordObsLink/" + utilisateur + "/" +idObs+ "/" + URL.encodeComponent(""+idMC) + "/") ;
String postData = "&action=DELETE";
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
oModele.obtenirListeObservation(r);
}
}) ;
} catch (RequestException e) {
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeReferentielPersoAsynchroneDAO.java
New file
0,0 → 1,103
package org.tela_botanica.client.modeles.dao;
 
import java.util.HashMap;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
public class ListeReferentielPersoAsynchroneDAO {
/**
* Cache
*
*/
private HashMap<String,ListeReferentielPerso> cache = new HashMap();
 
private TypesReferentiels refDemande = null;
public ListeReferentielPersoAsynchroneDAO(ObservationModele obs) {
}
public void setRefDemande(TypesReferentiels refDemande) {
this.refDemande = refDemande;
}
public void obtenirListeDonnees(final Rafraichissable r, String utilisateur, final String critere) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() +
"/SelfRefList/"+
utilisateur+"/"+
refDemande.toString()+
"?start=0&limit=50&recherche="+URL.encode(critere));
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeReferentielPerso referentielData;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = null;
// si c'est un tableau
if ((reponse = responseValue.isArray()) != null) {
JSONString elementsRef;
final int taillemax = reponse.size();
referentielData = new ListeReferentielPerso(taillemax, refDemande);
for (int i = 0; i < taillemax; i++) {
if ((elementsRef = reponse.get(i).isString()) != null) {
String valeur = elementsRef.stringValue();
referentielData.put(i+"", valeur);
}
}
} else {
referentielData = new ListeReferentielPerso(0, refDemande);
}
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
r.rafraichir(referentielData, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ImageUploaderAsynchroneDAO.java
New file
0,0 → 1,165
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.gwtext.client.core.UrlParam;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.WindowListenerAdapter;
import com.gwtextux.client.widgets.upload.UploadDialog;
import com.gwtextux.client.widgets.upload.UploadDialogListenerAdapter;
 
/**
* DAO un peu particulier car il crée une fenetre d'upload différente suivant
* que le plugin Java est détecté ou non
*
*
*/
public class ImageUploaderAsynchroneDAO {
 
/**
* Modele associé au DAO
*/
private static ImageModele iModele;
 
public ImageUploaderAsynchroneDAO(ImageModele im) {
iModele = im;
}
 
/**
* Setteur pour le modele
*
* @param im
* le modèle à associer au DAO
*/
public void setIModele(ImageModele im) {
iModele = im;
}
 
/**
* Crée un panel d'upload simple aux fonctions réduites mais utilisant
* uniquement javascript (pour les utilisateurs qui n'ont pas java)
*/
public static void appelerUploadSimple() {
 
UploadDialog up = new UploadDialog("Upload simple de fichiers");
up.setUrl(Configuration.getServiceBaseUrl() + "/InventoryImage");
UrlParam id = new UrlParam("ce_utilisateur",Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
UrlParam[] params = { id };
up.setBaseParams(params);
up.setModal(true);
 
up.addListener(new UploadDialogListenerAdapter() {
 
@Override
public void onClose(Panel panel) {
iModele.setDernierePage();
iModele.requeteTerminee();
}
 
@Override
public void onUploadComplete(UploadDialog source) {
iModele.setDernierePage();
iModele.requeteTerminee();
 
}
 
});
 
up.show();
 
}
 
/**
* Crée une fenêtre contenant une applet java pour uploader plusieurs
* fichiers à la fois avec quelques fonctions avancées (nécessite le plugin
* java pour le navigateur)
*/
public static void appelerUploadMultiple() {
 
final Window nPan = new Window("Upload multiple");
nPan.setWidth(640);
 
final String warning = "<p class=\"warning_upload\"> A la fin de l'envoi, veuillez fermer la fenêtre pour accéder aux images. </p>";
 
final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" name=\"JUpload\" archive=\"wjhk.jupload.jar\" alt=\"Le plugin java n'est pas installé\" mayscript=\"true\" height=\"350\" width=\"625\">";
final String paramPostTarget = "<param name=\"postURL\" value=\""
+ Configuration.getServiceBaseUrl()
+ "/InventoryImage/\">";
final String paramUploadPolicy = "<param name=\"uploadPolicy\" value=\"PictureUploadPolicy\">";
final String paramMaxChunkSize = "<param name=\"maxChunkSize\" value=\"0\">";
final String paramMaxFileSize = "<param name=\"maxFileSize\" value=\""+Configuration.getTailleMaxUpload()+"\">";
final String paramTransmitMetaData = "<param name=\"pictureTransmitMetadata\" value=\"true\">";
final String paramFilesPerRequest = "<param name=\"nbFilesPerRequest\" value=\"1\">";
final String paramAllowedExtensions = "<param name=\"allowedFileExtensions\" value=\"jpg/jpeg/\">";
final String paramUploadSuccess = "<param name=\"stringUploadSuccess\" value=\"OK\">";
final String paramShowLogWindow = "<param name=\"showLogWindow\" value=\"false\">";
final String paramFormdata = "<param name=\"formData\" value=\"postid\">";
final String finApplet = "</applet>";
 
final String appelApplet = applet + paramPostTarget + paramUploadPolicy
+ paramMaxChunkSize + paramMaxFileSize + paramTransmitMetaData
+ paramFilesPerRequest + paramAllowedExtensions
+ paramUploadSuccess + paramShowLogWindow + paramFormdata
+ finApplet;
 
final String htmlForm = "<form method=\"post\" name=\"postid\">"
+ "<input type=\"hidden\" name=\"ce_utilisateur\" value=\""
+ Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "\">" + "</form>";
 
nPan.setHtml(warning + appelApplet + htmlForm);
 
nPan.setModal(true);
 
nPan.addListener(new WindowListenerAdapter() {
 
@Override
public void onClose(Panel panel) {
iModele.setDernierePage();
iModele.requeteTerminee();
}
 
});
 
nPan.show();
}
 
/**
* Fonction javascript native qui détecte la présence du plugin java pour le
* navigateur et appelle la méthode d'upload adaptée (appelerUploadSimple ou
* appelerUploadMultiple)
*/
public static native void choisirMethodeUpload() /*-{
var agt=navigator.userAgent.toLowerCase();
var ie = (agt.indexOf("msie") != -1);
var ns = (navigator.appName.indexOf("Netscape") != -1);
var win = ((agt.indexOf("win")!=-1) || (agt.indexOf("32bit")!=-1));
var mac = (agt.indexOf("mac")!=-1);
function detectIE(ClassID,name) { result = false; document.write('<SCRIPT LANGUAGE=VBScript>\n on error resume next \n result = IsObject(CreateObject("' + ClassID + '"))</SCRIPT>\n'); if (result) return name+','; else return ''; }
function detectNS(ClassID,name) { n = ""; if (nse.indexOf(ClassID) != -1) if (navigator.mimeTypes[ClassID].enabledPlugin != null) n = name+","; return n; }
if (ie && win) { pluginlist = detectIE("Adobe.SVGCtl","SVG Viewer") + detectIE("SWCtl.SWCtl.1","Shockwave Director") + detectIE("ShockwaveFlash.ShockwaveFlash.1","Shockwave Flash") + detectIE("rmocx.RealPlayer G2 Control.1","RealPlayer") + detectIE("QuickTimeCheckObject.QuickTimeCheck.1","QuickTime") + detectIE("MediaPlayer.MediaPlayer.1","Windows Media Player") + detectIE("PDF.PdfCtrl.5","Acrobat Reader"); }
if (ns || !win) {
nse = ""; for (var i=0;i<navigator.mimeTypes.length;i++) nse += navigator.mimeTypes[i].type.toLowerCase();
pluginlist = detectNS("image/svg-xml","SVG Viewer") + detectNS("application/x-director","Shockwave Director") + detectNS("application/x-shockwave-flash","Shockwave Flash") + detectNS("audio/x-pn-realaudio-plugin","RealPlayer") + detectNS("video/quicktime","QuickTime") + detectNS("application/x-mplayer2","Windows Media Player") + detectNS("application/pdf","Acrobat Reader");
}
pluginlist += navigator.javaEnabled() ? "Java," : "";
if (pluginlist.length > 0) pluginlist = pluginlist.substring(0,pluginlist.length-1);
if(pluginlist.indexOf("Java")!=-1)
{
@org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO::appelerUploadMultiple()() ;
}
else
{
@org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO::appelerUploadSimple()() ;
}
}-*/;
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeReferentielNomAsynchroneDAO.java
New file
0,0 → 1,158
package org.tela_botanica.client.modeles.dao;
 
import java.util.HashMap;
 
import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeReferentielNom;
import org.tela_botanica.client.modeles.objets.ReferentielNom;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO liste noms scientifiques // utilisation d'un cahce memoire pour eviter des requetes inutiles.
* @author David Delon
*
*/
public class ListeReferentielNomAsynchroneDAO implements FournisseurListe {
 
 
//TODO : limiter taille du cache ? (si pb performance)
/**
* Le modèle associé au DAO
*/
private ObservationModele observationModele = null ;
private String referentiel = null;
/**
* Cache
*
*/
private HashMap <String,ListeReferentielNom> cache = new HashMap();
 
public ListeReferentielNomAsynchroneDAO(ObservationModele observationModele)
{
this.observationModele=observationModele;
}
/**
* Envoie une requete au serveur jrest pour obtenir les communes correspondant
* à des critères données en paramètres
* @param r le rafraichissable qui demande la mise à jour
* @param criteres un string contenant le terme a rechercher
*/
@Override
public void obtenirListeDonnees(final Rafraichissable r,final String referentiel, final String critere)
{
ListeReferentielNom referentielNomDataFromCache=null;
if(this.referentiel != referentiel) {
cache.clear();
}
// En cache ?
if ((referentielNomDataFromCache=getFromCache(critere))!=null) {
r.rafraichir(referentielNomDataFromCache,true);
}
else {
// On vérifie si un genre et une espèce sont demandées
// et ajoute le / manuellement car sinon il devient urlencode
String[] criteres =critere.split("/");
String urlParams = "/NameSearch/"+referentiel+"/";
if(criteres.length > 1) {
String critere1 = criteres[0];
String critere2 = criteres[1];
urlParams += URL.encode(critere1)+"/"+URL.encode(critere2);
} else {
urlParams += URL.encode(critere);
}
this.referentiel = referentiel;
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()+urlParams);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
final ListeReferentielNom referentielNomData ;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse=null;
// si c'est un tableau
if ((reponse=responseValue.isArray()) != null) {
JSONArray noms;
final int taillemax = reponse.size();
referentielNomData = new ListeReferentielNom(taillemax);
for (int i = 0; i < taillemax; i++) {
if ((noms=reponse.get(i).isArray()) != null) {
String nom = ((JSONString) noms.get(0)).stringValue();
String numeroNom = ((JSONString) noms.get(1)).stringValue();
String statut= ((JSONString) noms.get(2)).stringValue();
ReferentielNom nomScientifique = new ReferentielNom(nom, numeroNom, statut);
// FIXME : et si le numero de nom n'est pas unique ? (cas de multirefrentiel....)
referentielNomData.put(nomScientifique.getNumeroNom(),nomScientifique);
}
}
} else {
referentielNomData = new ListeReferentielNom(0) ;
}
addToCache(critere, referentielNomData);
r.rafraichir(referentielNomData,true);
}
}) ;
} catch(RequestException e) {
}
} // fin else si pas de cache
}
@Override
public void obtenirListeDonnees(Rafraichissable r, String critere) {
obtenirListeDonnees(r, "bdtfx", critere);
}
private void addToCache(String query, ListeReferentielNom result) {
cache.put(query.toLowerCase(),result);
}
 
private ListeReferentielNom getFromCache (String query) {
return cache.get(query.toLowerCase());
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/InformationCommuneDAO.java
New file
0,0 → 1,167
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
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.Window;
 
public class InformationCommuneDAO {
 
private final String NOM_SERVICE = "CoordSearch";
private final String CODE_PAYS = "FR";
 
Rafraichissable r = null;
 
public InformationCommuneDAO(Rafraichissable r) {
this.r = r;
}
 
public void obtenirCommunePlusProche(final Rafraichissable r, final double lng,
final double lat) {
 
String adresseAppel = Configuration.getServiceBaseUrl() + "/"
+ NOM_SERVICE + "/" + URL.encode("" + lat) + "/"
+ URL.encode("" + lng) + "/*/*/";
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel);
 
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
Window.alert(exception.getMessage());
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
EntiteGeographiqueObservation infos;
String idLocalite = "";
String nomCommune = "";
 
if (response.getStatusCode() == Response.SC_BAD_REQUEST) {
Window.alert("Requete mal formée");
} else {
if(response.getText().equals("")) {
 
infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null);
infos.setLat(""+lat);
infos.setLon(""+lng);
r.rafraichir(infos, false);
}
final JSONValue responseValue = JSONParser
.parse(response.getText());
 
if (responseValue.isObject() != null) {
JSONObject objectRetour = responseValue.isObject();
if(objectRetour.get("nom").isString() != null) {
nomCommune = objectRetour.get("nom").isString().stringValue();
}
if(objectRetour.get("code_insee").isString() != null) {
idLocalite = objectRetour.get("code_insee").isString().stringValue().substring(0, 2);
}
}
}
infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null);
infos.setLat(""+lat);
infos.setLon(""+lng);
 
r.rafraichir(infos, false);
}
});
} catch (RequestException e) {
Window.alert(e.getMessage());
}
}
 
public void obtenirInfosCommune(final Rafraichissable r,
String valeurCommune, String codePostal) {
codePostal = codePostal.replaceAll("000null", "*");
codePostal = codePostal.replaceAll("\"", "");
valeurCommune = valeurCommune.split(" \\([0-9][0-9]\\)")[0];
valeurCommune = valeurCommune.replaceAll("000null", "*");
valeurCommune = valeurCommune.replaceAll("\"", "");
String adresseAppel = Configuration.getServiceBaseUrl() + "/"
+ NOM_SERVICE + "/*/*/" + URL.encode(valeurCommune) + "/"
+ URL.encode(codePostal) + "/"
+ URL.encode(CODE_PAYS);
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, adresseAppel);
 
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
Window.alert(exception.getMessage());
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getStatusCode() == Response.SC_BAD_REQUEST) {
r.rafraichir("Impossible de géolocaliser cette observation", false);
} else {
final JSONValue responseValue = JSONParser
.parse(response.getText());
if (responseValue.isObject() != null) {
EntiteGeographiqueObservation infos;
Double lng = 0.0;
Double lat = 0.0;
JSONObject objectRetour = responseValue.isObject();
String nomCommune = Util.getValeurJsonOuVide(objectRetour, "nom");
String idLocalite = Util.getValeurJsonOuVide(objectRetour, "code_insee");
lat = Util.jsonNonNull(objectRetour,"lat") ? objectRetour.get("lat").isNumber().doubleValue(): 0.0;
lng = Util.jsonNonNull(objectRetour,"lng") ? objectRetour.get("lng").isNumber().doubleValue(): 0.0;
infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null);
infos.setLat(""+lat);
infos.setLon(""+lng);
r.rafraichir(infos, false);
} else {
EntiteGeographiqueObservation infos;
String idLocalite = "";
String nomCommune = "";
 
infos = new EntiteGeographiqueObservation(idLocalite, nomCommune, null, null);
infos.setLat("");
infos.setLon("");
r.rafraichir(infos, false);
}
}
}
});
} catch (RequestException e) {
Window.alert(e.getMessage());
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeDateImageAsynchroneDAO.java
New file
0,0 → 1,84
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeDate;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONValue;
 
public class ListeDateImageAsynchroneDAO {
/**
* Le modèle associé au DAO.
*/
private ImageModele imageModele = null;
/**
* Constructeur.
* @param obs : Modele
*/
public ListeDateImageAsynchroneDAO(final ImageModele obs) {
this.imageModele = obs;
}
/**
* Envoie une requete au serveur jrest pour obtenir les communes correspondant
* à des critères données en paramètres.
* @param r le rafraichissable qui demande la mise à jour
* @param critere un string contenant le terme a rechercher
*/
public final void obtenirListeDate(final Rafraichissable r, final String utilisateur) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/ImageDateList/" + utilisateur);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeDate lDateObs;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = responseValue.isArray();
// si c'est un tableau
lDateObs = (reponse) != null ? new ListeDate(reponse) : new ListeDate(0);
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
r.rafraichir(lDateObs, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
 
}
 
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ImageAsynchroneDAO.java
New file
0,0 → 1,181
package org.tela_botanica.client.modeles.dao;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
 
/**
* DAO d'accès à une image, n'est utilisé que pour l'écriture et pas pour la
* lecture des images qui se fait par paquet
*
* @author aurelien
*
*/
public class ImageAsynchroneDAO {
 
ImageModele iModele = null;
 
public ImageAsynchroneDAO(ImageModele im) {
iModele = im;
}
 
public void setIModele(ImageModele im) {
iModele = im;
}
 
/**
* Met à jour la base de données avec toutes les données d'une image
*
* @param ic
* l'image à mettre à jour
*/
public void SynchroniserBaseDeDonnees(final ImageCarnet ic) {
String postData = "";
 
String[][] champsModifiables = ic.obtenirChampsModifiablesImage();
for (int i = 0; i < champsModifiables.length; i++) {
postData += "&"+champsModifiables[i][0]+"="+champsModifiables[i][1];
}
 
// et on envoie une requête asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/inventoryImage/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+"/"+ic.getId());
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getText().equals("OK")) {
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
}
 
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
/**
* Met à jour la base de données avec les mots clés associés à l'image
*
* @param ic
* l'image à mettre à jour
*/
public void SynchroniserMotsClesImageBaseDeDonnees(final ImageCarnet ic) {
String postData = "";
 
// on récupère les mots clés de l'image et on fabrique le post
String motsCles = ic.getMotsCles();
String id = ic.getId();
postData += "&id_image=" + id + "&id_mot_cle_utilisateur=" + motsCles;
 
// on envoie une requête asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,
Configuration.getServiceBaseUrl()
+ "/inventoryKeyWordImageList/" +Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()+ "/");
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
// TODO: les messages ne devraient pas être affichés ici
// mais l'architecture par très malléable complique les choses
if (response.getText().equals("OK")) {
com.google.gwt.user.client.Window
.alert("Les mots clés suivants ont bien été appliqués : "+iModele.renvoyerChaineMotClesTexte(ic));
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText());
}
}
 
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
/**
* Supprime une image de la base de données
*
* @param ic
* l'image à supprimer
*/
public void supprimerBaseDeDonnees(final ImageCarnet ic) {
// le post contient l'action delete pour JREST (qui ne gère pas DELETE
// comme une requête à part entière)
String postData = "";
postData += "&action=DELETE";
 
// on envoie un post avec l'id de l'image à supprimer
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/inventoryImage/"
+ iModele.getIdentifiant()
+ "/"
+ ic.getId());
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getText().equals("OK")) {
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données : "+response.getText());
}
}
 
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeImageAsynchroneDAO.java
New file
0,0 → 1,251
package org.tela_botanica.client.modeles.dao;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
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;
 
/**
* Data Object Access communiquant avec le serveur jrest fournissant la liste
* des images répondant à des critères donné
*
* @author aurelien
*
*/
public class ListeImageAsynchroneDAO {
 
/**
* Le modèle associé au DAO
*/
ImageModele iModele = null;
 
public ListeImageAsynchroneDAO(ImageModele im) {
iModele = im;
}
 
/**
* Setteur pour le modèle
*
* @param im
* le modèle à associer
*/
public void setIModele(ImageModele im) {
iModele = im;
}
 
/**
* Envoie une requete au serveur jrest pour obtenir une liste d'images
* correspondant à des critères demandés
*
* @param r
* le rafraichissable qui a demandé les données
* @param criteres
* un tableau contenant les critères de selections
*/
public void ObtenirListeImages(final Rafraichissable r, String[][] criteres) {
 
String requete = "";
 
// on construit les paramètres du get
if (criteres != null) {
for (int i = 0; i < criteres.length; i++) {
 
if (!criteres[i][1].equals("")) {
if (i != 0) {
requete += "&";
}
requete += criteres[i][0] + "=" + criteres[i][1];
 
}
}
}
 
// on envoie le get asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/InventoryImageList/"
+ Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()
+ "/?"
+ requete);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
final ListeImageCarnet photoData;
 
final JSONValue responseValue = JSONParser.parse(response
.getText());
// si c'est un tableau
if (responseValue.isArray() != null) {
 
final JSONArray reponse = responseValue.isArray();
 
final int taillemax = reponse.size();
photoData = new ListeImageCarnet(taillemax);
 
// on le parcourt
for (int j = 0; j < taillemax; j++) {
 
JSONObject image = (JSONObject) reponse.get(j);
 
ImageCarnet im = new ImageCarnet(image);
 
// et on en extrait les données pour construire la
// liste d'image
photoData.put(im.getOrdre(), im);
 
}
} else {
// si c'est un objet alors il n'y a qu'une réponse
if (responseValue.isObject() != null) {
photoData = new ListeImageCarnet(1);
ImageCarnet im = new ImageCarnet(responseValue
.isObject());
// on crée une liste de 1 élement auquel on ajoute
// ce qui a été reçu
photoData.put(im.getOrdre(), im);
} else {
// sinon on crée une liste vide
photoData = new ListeImageCarnet(0);
}
}
 
// dans tous les cas on transmet la liste crée au
// rafraichissable en lui demandant de répandre les données
// car il est
// le premier à les recevoir
r.rafraichir(photoData, true);
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
/**
* Met à jour les valeurs d'une liste d'image donnée dans la base de données
*
* @param li
* la liste d'image à synchroniser avec la base
*/
public void SynchroniserBaseDeDonnees(ListeImageCarnet li) {
// on parcourt toute la liste d'image
for (Iterator<String> listIt = li.keySet().iterator(); listIt.hasNext();) {
String postData = "";
 
ImageCarnet enCours = li.get(listIt.next());
 
String[][] champsModifiables = enCours.obtenirChampsModifiablesImage();
for (int i = 0; i < champsModifiables.length; i++) {
postData += "&"+champsModifiables[i][0]+"="+champsModifiables[i][1];
}
 
// on fait un post asynchrone et on les envoie à jrest
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,
Configuration.getServiceBaseUrl()
+ "/inventoryImage/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/");
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getText().equals("OK")) {
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
}
 
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
 
/**
* Supprime des image sur le serveur par rapport à leur identifant
*
* @param ids
* un tableau d'identifiants d'images à supprimer
*/
public void supprimerBaseDeDonnees(String[] ids) {
String postData = "";
// on fait un delete dans le post (jrest ne gère pas delete comme une
// action à part entière)
postData += "&action=DELETE";
 
String uid = "";
 
// on concatène les ids
for (int i = 0; i < ids.length; i++) {
 
uid += ids[i] + ",";
}
 
// et on envoie ça au serveur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/inventoryImageList/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + uid);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
// quand la requête est éxecutée on le signale au modèle
// poru qu'il mette à jour les données
// et en notifie le médiateur
iModele.requeteTerminee();
 
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/NombreImageAsynchroneDAO.java
New file
0,0 → 1,116
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO qui renvoie le nombre d'image associées à différents critères donnés
* (utile pour la pagination)
*
* @author aurelien
*
*/
public class NombreImageAsynchroneDAO {
 
/**
* Le modèle associé au DAO
*/
private ImageModele iModele = null;
 
public NombreImageAsynchroneDAO(ImageModele im) {
iModele = im;
}
 
/**
* Setteur pour le modèle
*
* @param im
* le modèlme à associer
*/
public void setIModele(ImageModele im) {
iModele = im;
}
 
/**
* Envoie une requete au serveur jrest pour obtenir le nombre d'images
* correspondant à des critères données en paramètres
*
* @param r
* le rafraichissable qui demande la mise à jour
* @param criteres
* un tableau nom/valeur des critères pour les images
*/
public void obtenirNombreImages(final Rafraichissable r, String[][] criteres) {
String requete = "";
 
if (criteres != null) {
// on construit les paramètres du get avec les critères
// (&critere1=valeur1&critere2=valeur2 etc...)
for (int i = 0; i < criteres.length; i++) {
 
if (!criteres[i][1].equals("")) {
if (i != 0) {
requete += "&";
}
requete += criteres[i][0] + "=" + criteres[i][1];
}
}
}
 
// on fait un get asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/InventoryImageCount/"
+ Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()
+ "/?"
+ requete);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
final JSONValue responseValue = JSONParser.parse(response
.getText());
 
// si la requete se passe bien on reçoit une chaine JSON
if (responseValue.isString() != null) {
// qui contient une valeur : le nombre d'images
// correspondant au critères
JSONString reponseNombre = responseValue.isString();
int maxImages = Integer.parseInt(reponseNombre
.stringValue());
int[] nbImages = { maxImages };
// on le met dans un tableau d'entiers qu'on transmet au
// demandeur de la mise à jour
r.rafraichir(nbImages, true);
}
 
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ExportObservationsDAO.java
New file
0,0 → 1,40
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Window;
 
public class ExportObservationsDAO {
 
ObservationModele om = null ;
public ExportObservationsDAO(ObservationModele observationModele) {
om = observationModele ;
}
 
public void exporterObservations(String identifiant, String[][] criteres, String format, String groupes) {
String requete = "colonnes=" + groupes ;
if(criteres != null)
{
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...)
for (int i = 0; i < criteres.length; i++) {
if(criteres[i] != null && criteres[i][1] != null && !criteres[i][1].equals(""))
{
requete += "&"+criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ;
}
}
}
requete += "&id_utilisateur="+identifiant+"&format="+format;
Window.open(Configuration.getServiceBaseUrl()+"/CelWidgetExport/export/?"+requete,"Export",null) ;
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ImportObservationAsynchroneDAO.java
New file
0,0 → 1,57
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
 
public class ImportObservationAsynchroneDAO {
 
private ObservationModele oModele = null ;
public ImportObservationAsynchroneDAO(ObservationModele observationModele) {
oModele = observationModele;
}
 
public void importerObservations() {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/InventoryImport/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
 
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if(response.getText().equals("OK")) {
oModele.obtenirNombreObservation(null);
}
else
{
}
 
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeReferentielCommuneAsynchroneDAO.java
New file
0,0 → 1,146
package org.tela_botanica.client.modeles.dao;
 
import java.util.HashMap;
 
import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeReferentielCommune;
import org.tela_botanica.client.modeles.objets.ReferentielCommune;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO la liste des communes. Utilisation d'un cache pour eviter les requetes inutiles
* @author David Delon
*
*/
public class ListeReferentielCommuneAsynchroneDAO implements FournisseurListe {
 
/**
* Le modèle associé au DAO.
*/
private ObservationModele observationModele = null;
/**
* Cache
*
*/
private HashMap<String,ListeReferentielCommune> cache = new HashMap();
/**
* Constructeur.
* @param obs : Modele
*/
public ListeReferentielCommuneAsynchroneDAO(final ObservationModele obs) {
this.observationModele = obs;
}
/**
* Envoie une requete au serveur jrest pour obtenir les communes correspondant
* à des critères données en paramètres.
* @param r le rafraichissable qui demande la mise à jour
* @param critere un string contenant le terme a rechercher
*/
@Override
public final void obtenirListeDonnees(final Rafraichissable r, final String critere) {
ListeReferentielCommune referentielCommuneDataFromCache=null;
// En cache ?
if ((referentielCommuneDataFromCache=getFromCache(critere))!=null) {
r.rafraichir(referentielCommuneDataFromCache,true);
}
else {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/LocationSearch/" + URL.encodeComponent(critere));
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeReferentielCommune referentielCommuneData;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = null;
// si c'est un tableau
if ((reponse = responseValue.isArray()) != null) {
JSONArray communes;
final int taillemax = reponse.size();
referentielCommuneData = new ListeReferentielCommune(taillemax);
for (int i = 0; i < taillemax; i++) {
if ((communes = reponse.get(i).isArray()) != null) {
String commune = ((JSONString) communes.get(0)).stringValue();
String departement = ((JSONString) communes.get(1)).stringValue();
ReferentielCommune com = new ReferentielCommune(commune, departement);
referentielCommuneData.put(com.getCommune() + com.getDepartement(), com);
}
}
} else {
referentielCommuneData = new ListeReferentielCommune(0);
}
addToCache(critere, referentielCommuneData);
r.rafraichir(referentielCommuneData, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
} // Fin else si pas de cache
}
/**
* Fonction à implémenter dans le futur, lors de l'utilisation de plusieurs
* référentiels de localité
*/
@Override
public void obtenirListeDonnees(Rafraichissable r, String referentiel, String critere) {
// TODO Auto-generated method stub
}
private void addToCache(String query, ListeReferentielCommune result) {
cache.put(query.toLowerCase(),result);
}
 
private ListeReferentielCommune getFromCache (String query) {
return cache.get(query.toLowerCase());
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/MotsClesAsynchroneDAO.java
New file
0,0 → 1,269
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.Window;
 
/**
* DAO d'accès à l'arbre de mots clés
*
* @author aurelien
*
*/
public class MotsClesAsynchroneDAO {
private String identifiant = "" ;
private String mode = "";
private String nomService = "InventoryKeywordTree";
//private String nomService = "InventoryKeyWordList";
 
public MotsClesAsynchroneDAO() {
mode = "images";
identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte();
}
public MotsClesAsynchroneDAO(String mode) {
this.mode = mode;
identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte();
}
 
/**
* Envoie une requete au serveur jrest pour obtenir l'arbre des mots clés
*
* @param r
* le rafraichissable qui demande les données
*/
public void obtenirListeMotsCles(final Rafraichissable r) {
// on demande tous les mots clés associés à l'utilisateur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/"+nomService+"/"+mode+"/"+identifiant+"/");
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
final JSONValue responseValue = JSONParser.parse(response
.getText());
// si la requête est un succès on reçoit un tableau
if (responseValue.isArray() != null) {
 
final JSONArray reponse = responseValue.isArray();
// et on met à jour le demandeur des données
r.rafraichir(reponse, true);
} else {
JSONArray vide = new JSONArray();
r.rafraichir(vide, true);
}
 
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
/**
* Envoie requete au serveur jrest pour ajouter un mot clé
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
* @param r
*/
public void ajouterBaseDeDonnees(String motcle, final Rafraichissable r) {
if (!motcle.equals("")) {
String postData = motcle+"&mode="+mode;
 
// on fait un post asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/"+nomService+"/");
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
// TODO: les messages ne devraient pas être affichés ici
// mais l'architecture pas très malléable complique les choses
try {
Integer idMotcle = Integer.parseInt(response.getText());
r.rafraichir(idMotcle, false);
} catch (Exception e) {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText());
}
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
 
/**
* Envoie requete au serveur jrest pour supprimer un mot clé
*
* @param motcle
* le mots clés à supprimer
*/
public void supprimerBaseDeDonnees(String motcle, final Rafraichissable r) {
if (!motcle.equals("")) {
String postData = "";
postData += "&action=DELETE";
 
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/"+nomService+"/"
+ mode+"/"
+ identifiant
+ "/"
+ motcle);
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
// TODO: les messages ne devraient pas être affichés ici
// mais l'architecture par très malléable complique les choses
if (response.getText().equals("OK")) {
com.google.gwt.user.client.Window
.alert("Le mot clé a été supprimé");
r.rafraichir(null, false);
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText());
}
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
 
/**
* Envoie requete au serveur jrest pour modifier un mot clé
*
* @param motcle
* le mots clés à modifier avec son parent et son identifiant
*/
public void modifierBaseDeDonnees(String motcle, final Rafraichissable r) {
//TODO : cette fonction n'a aucun sens, on lui passe une sorte de chaine
// de requete url, elle devrait avoir au moins trois paramètres qu'elle assemble elle même
if (!motcle.equals("")) {
 
String postData = "";
postData += "&action=modification"+motcle;
 
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/"+nomService+"/"+mode+"/"+ identifiant);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
// TODO: les messages ne devraient pas être affichés ici
// mais l'architecture par très malléable complique les choses
if (response.getText().equals("OK")) {
com.google.gwt.user.client.Window
.alert("Le mot clé a été renommé");
r.rafraichir(null, false);
return;
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données, le serveur a répondu "+response.getText());
}
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
 
/**
* Envoie requete au serveur jrest pour modifier un mot clé
*
* @param motcle
* le mots clés à ajouter avec son ancien parent, son nouveau et
* son identifiant
*/
public void deplacerBaseDeDonnees(String motcle, final Rafraichissable r) {
 
if (!motcle.equals("")) {
 
String postData = "";
postData += "&action=deplacement"+motcle;
 
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/"+nomService+"/"+mode+"/"+identifiant);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
r.rafraichir(null, false);
}
 
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeDateObservationAsynchroneDAO.java
New file
0,0 → 1,87
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeDate;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONValue;
 
public class ListeDateObservationAsynchroneDAO {
/**
* Le modèle associé au DAO.
*/
private ObservationModele observationModele = null;
/**
* Constructeur.
* @param obs : Modele
*/
public ListeDateObservationAsynchroneDAO(final ObservationModele obs) {
this.observationModele = obs;
}
/**
* Envoie une requete au serveur jrest pour obtenir les communes correspondant
* à des critères données en paramètres.
* @param r le rafraichissable qui demande la mise à jour
* @param critere un string contenant le terme a rechercher
*/
public final void obtenirListeDate(final Rafraichissable r, final String utilisateur) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl() + "/InventoryDateList/" + utilisateur);
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeDate lDateObs;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse = responseValue.isArray();
 
// si c'est un tableau
lDateObs = (reponse) != null ? new ListeDate(reponse) : new ListeDate(0);
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
r.rafraichir(lDateObs, true);
}
});
} catch (RequestException e) {
e.printStackTrace();
}
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/LienImageAsynchroneDAO.java
New file
0,0 → 1,248
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.observation.ObservationModele;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
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;
 
public class LienImageAsynchroneDAO {
 
private ImageModele iModele = null ;
private ObservationModele oModele = null ;
private Rafraichissable raf = null ;
public LienImageAsynchroneDAO(ImageModele im) {
iModele = im;
}
public LienImageAsynchroneDAO(ObservationModele om) {
oModele = om;
}
 
/**
* Setteur pour le modèle
*
* @param im
* le modèle à associer
*/
public void setIModele(ImageModele im) {
iModele = im;
}
public void obtenirLiaisonsImagesObservations(Rafraichissable r,String id)
{
String paramGet = "id_image="+id ;
raf = r ;
// et on envoie ça au serveur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/inventoryImageLink/" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "/" + paramGet);
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
@Override
public void onResponseReceived(Request request,
Response response) {
final ListeObservation observationData ;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse=null;
// si c'est un tableau
if ((reponse=responseValue.isArray()) != null) {
JSONObject observation;
final int taillemax = reponse.size();
observationData = new ListeObservation(taillemax);
for (int i = 0; i < taillemax; i++) {
if ((observation = reponse.get(i).isObject()) != null) {
Observation obs= new Observation(observation);
observationData.put(obs.getNumeroOrdre(),obs);
}
}
} else {
observationData = new ListeObservation(0) ;
}
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
// TODO : ce n'est pas ici qu'on devrait le decider ..
raf.rafraichir(observationData,true);
}
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void obtenirLiaisonsObservationsImages(Rafraichissable r,String idObs, String utilisateur)
{
String paramGet = "id_observation="+idObs ;
raf = r ;
 
// et on envoie ça au serveur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, Configuration.getServiceBaseUrl()
+ "/inventoryImageLink/" + utilisateur + "/" + paramGet);
try {
rb.sendRequest(null, new RequestCallback() {
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
@Override
public void onResponseReceived(Request request,
Response response) {
String baseUrl = Configuration.getImageBaseUrl() ;
final JSONValue responseValue = JSONParser.parse(response
.getText());
// si c'est un tableau
if (responseValue.isArray() != null) {
 
final JSONArray reponse = responseValue.isArray();
final int taillemax = reponse.size();
String imgTab[][] = new String[taillemax][3] ;
for(int i = 0 ;i<taillemax ;i++)
{
final JSONObject reponseInt = reponse.get(i).isObject();
String idImg = Util.getValeurJsonOuVide(reponseInt, "id_image") ;
String X = Util.getValeurJsonOuVide(reponseInt, "hauteur") ;
String Y = Util.getValeurJsonOuVide(reponseInt, "largeur") ;
imgTab[i][0] = idImg ;
imgTab[i][1] = X ;
imgTab[i][2] = Y ;
}
raf.rafraichir(imgTab, false) ;
}
else
{
String imgTab[] = new String[0] ;
raf.rafraichir(imgTab, false) ;
}
}
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void lierImageBaseDeDonnees(String idsImages, String idsObs) {
String postData = "";
postData += "id_image="+idsImages ;
postData += "&id_observation="+idsObs ;
postData += "&ce_utilisateur="+Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() ;
 
// et on envoie ça au serveur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/inventoryImageLink/");
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
iModele.requeteTerminee();
 
}
});
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
 
public void supprimerLienImageObservation(String idImg, String idObs) {
String postData = "";
postData += "&action=DELETE" ;
String identifiant = "" ;
identifiant = Utilisateur.getInstance().getIdentifiantUtilisateurConsulte();
// et on envoie ça au serveur
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST, Configuration.getServiceBaseUrl()
+ "/inventoryImageLink/"+identifiant+"/"+idImg+"/"+idObs);
try {
rb.sendRequest(postData, new RequestCallback() {
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
@Override
public void onResponseReceived(Request request,
Response response) {
// quand la requête est éxecutée on le signale au modèle
// pour qu'il mette à jour les données
// et en notifie le médiateur
iModele.requeteTerminee();
}
});
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ObservationAsynchroneDAO.java
New file
0,0 → 1,205
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.observation.ObservationModele;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Window;
 
 
/**
* DAO d'accès a une observation
*
* @author aurelien
*
*/
public class ObservationAsynchroneDAO {
 
/**
* Le modele associé au DAO
*/
private ObservationModele oModele = null;
 
public ObservationAsynchroneDAO(ObservationModele obs) {
oModele = obs;
}
 
/**
* Setteur pour le modèle
*
* @param obs
* le modèle à associer
*/
public void setoModele(ObservationModele obs) {
oModele = obs;
}
 
/**
* Envoie requete au serveur pour ajouter une observations
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
*/
public void ajouter(final Rafraichissable r, String utilisateur, final Observation obs) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/Inventory/") ;
rb.setHeader("Content-type", "application/x-www-form-urlencoded");
String postData = "ce_utilisateur="
+ utilisateur
+"&nom_sel="+URL.encodeComponent(obs.getNomSaisi())
+"&nom_sel_nn="+obs.getNumeroNomenclaturalSaisi()
+"&zone_geo="+URL.encodeComponent(obs.getLocalite())
+"&ce_zone_geo="+obs.getIdentifiantLocalite()
+"&date_observation=" + obs.getDate()
+"&lieudit="+ URL.encodeComponent(obs.getLieudit())
+"&station="+URL.encodeComponent(obs.getStation())
+"&milieu="+URL.encodeComponent(obs.getMilieu())
+"&commentaire="+obs.getCommentaire()
+"&latitude="+URL.encodeComponent(""+obs.getLatitude())
+"&longitude="+URL.encodeComponent(""+obs.getLongitude())
+"&altitude="+URL.encodeComponent(""+obs.getAltitude())
+"&abondance="+URL.encodeComponent(""+obs.getAbondance())
+"&certitude="+URL.encodeComponent(""+obs.getCertitude())
+"&phenologie="+URL.encodeComponent(""+obs.getPhenologie())
+"&nom_referentiel="+URL.encodeComponent(""+obs.getCodeCourtReferentielTaxo())
+"&obs_etendue="+URL.encodeComponent(""+Util.convertirChampsEtendusEnChaineRequete(obs.getChampsEtendus()));
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
if(response.getStatusCode() >= 400) {
com.google.gwt.user.client.Window.alert(response.getText());
}
r.rafraichir(obs,true);
}
}) ;
} catch (RequestException e) {
}
}
/**
* Envoie requete au serveur pour modifier une observations
*
* @param motcle
* le mots clés à ajouter avec son parent et son identifiant
*/
public void modifier(final Rafraichissable r, String utilisateur, final Observation obs) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/Inventory/" + utilisateur + "/" + obs.getNumeroOrdre()+ "/") ;
rb.setHeader("Content-type", "application/x-www-form-urlencoded");
String postData = "ce_utilisateur="
+ utilisateur
+ "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi())
+ "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi()
+ "&zone_geo=" + URL.encodeComponent(obs.getLocalite())
+ "&ce_zone_geo=" + obs.getIdentifiantLocalite()
+ "&date_observation=" + obs.getDate()
+ "&lieudit="+ URL.encodeComponent(obs.getLieudit())
+ "&station="+ URL.encodeComponent(obs.getStation())
+"&milieu="+ URL.encodeComponent(obs.getMilieu())
+"&commentaire="+obs.getCommentaire()
+"&latitude="+URL.encodeComponent(""+obs.getLatitude())
+"&longitude="+URL.encodeComponent(""+obs.getLongitude())
+"&altitude="+URL.encodeComponent(""+obs.getAltitude())
+"&abondance="+URL.encodeComponent(""+obs.getAbondance())
+"&certitude="+URL.encodeComponent(""+obs.getCertitude())
+"&phenologie="+URL.encodeComponent(""+obs.getPhenologie())
+"&nom_referentiel="+URL.encodeComponent(""+obs.getCodeCourtReferentielTaxo())
+"&obs_etendue="+URL.encodeComponent(""+Util.convertirChampsEtendusEnChaineRequete(obs.getChampsEtendus()));
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
if(response.getStatusCode() >= 400) {
com.google.gwt.user.client.Window.alert(response.getText());
}
r.rafraichir(obs,true);
}
}) ;
} catch (RequestException e) {
}
}
 
public void supprimer(Rafraichissable r, String identifiant, String numeroOrdre) {
String postData = "";
postData += "&action=DELETE";
 
// on envoie un post avec l'id de l'image à supprimer
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,
Configuration.getServiceBaseUrl()
+ "/inventory/"
+ identifiant
+ "/"
+ numeroOrdre);
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getText().equals("OK")) {
 
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
return ;
}
}
 
});
r.rafraichir("OK", true) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/ListeObservationAsynchroneDAO.java
New file
0,0 → 1,273
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
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;
 
/**
* DAO la liste des observations attachées a un observateur.
* @author David Delon
* TODO : se servir de ObservationDAO pour la lecture unitaire
*
*/
public class ListeObservationAsynchroneDAO {
 
 
/**
* Le modèle associé au DAO.
*/
private ObservationModele observationModele = null;
private ImageModele imageModele = null;
 
public ListeObservationAsynchroneDAO(final ObservationModele obs) {
this.observationModele=obs;
}
/**
* Le modèle associé au DAO.
*/
 
public ListeObservationAsynchroneDAO(final ImageModele img) {
this.imageModele = img;
}
/**
* Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant
* à des critères données en paramètres
* @param r le rafraichissable qui demande la mise à jour
* @param criteres un tableau nom/valeur des critères pour les observations
*/
public final void obtenirListeObservation(final Rafraichissable r, final String utilisateur, final String[][] criteres)
{
String requete = "" ;
if(criteres != null)
{
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...)
// ils contiennent limite et taille page et autres filtres (communes , lieu dit etc ...)S
for (int i = 0; i < criteres.length; i++) {
if(criteres[i][1] != null && !criteres[i][1].equals(""))
{
if(i!= 0)
{
requete += "&";
}
requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ;
}
}
}
// on envoie le get asynchrone
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()
+"/InventoryObservationList/"+utilisateur+"/?"+requete) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(final Request request, final Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(final Request request,
final Response response) {
final ListeObservation observationData ;
final JSONValue responseValue = JSONParser.parse(response.getText());
JSONArray reponse=null;
// si c'est un tableau
if ((reponse=responseValue.isArray()) != null) {
JSONObject observation;
final int taillemax = reponse.size();
observationData = new ListeObservation(taillemax);
for (int i = 0; i < taillemax; i++) {
if ((observation=reponse.get(i).isObject()) != null) {
Observation obs = new Observation(observation);
observationData.put(obs.getNumeroOrdre(),obs);
}
}
} else {
observationData = new ListeObservation(0) ;
}
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est
// le premier à les recevoir
// TODO : ce n'est pas ici qu'on devrait le decider ..
r.rafraichir(observationData,true);
}
}) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void modifierEnMasse(final Rafraichissable r, String identifiant,
final Observation obs) {
 
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,Configuration.getServiceBaseUrl()+ "/InventoryObservationList/" + identifiant + "/" + obs.getNumeroOrdre()+ "/") ;
String postData = "ce_utilisateur="
+ identifiant ;
if(obs.getNomSaisi() != null) {
postData += "&nom_sel=" + URL.encodeComponent(obs.getNomSaisi());
}
if(obs.getNumeroNomenclaturalSaisi() != null) {
postData += "&nom_sel_nn=" + obs.getNumeroNomenclaturalSaisi();
}
if(obs.getIdentifiantLocalite() != null) {
postData += "&ce_zone_geo=" + obs.getIdentifiantLocalite();
}
if(obs.getLocalite() != null) {
postData += "&zone_geo=" + URL.encodeComponent(obs.getLocalite());
}
if(obs.getDate() != null) {
postData += "&date_observation=" + obs.getDate();
}
if(obs.getLieudit() != null) {
postData += "&lieudit="+ URL.encodeComponent(obs.getLieudit());
}
if(obs.getStation() != null) {
postData += "&station="+ URL.encodeComponent(obs.getStation());
}
if(obs.getMilieu() != null) {
postData += "&milieu="+ URL.encodeComponent(obs.getMilieu());
}
if(obs.getCommentaire() != null) {
postData += "&commentaire="+obs.getCommentaire();
}
if(obs.getLatitude() != null ) {
postData += "&latitude="+URL.encodeComponent(""+obs.getLatitude());
}
if(obs.getLongitude() != null) {
postData += "&longitude="+URL.encodeComponent(""+obs.getLongitude());
}
if(obs.getAltitude() != null) {
postData += "&altitude="+URL.encodeComponent(""+obs.getAltitude());
}
if(obs.getAbondance() != null) {
postData += "&abondance="+URL.encodeComponent(""+obs.getAbondance());
}
if(obs.getCertitude() != null) {
postData += "&certitude="+URL.encodeComponent(""+obs.getCertitude());
}
if(obs.getPhenologie() != null) {
postData += "&phenologie="+URL.encodeComponent(""+obs.getPhenologie());
}
if(obs.getReferentielTaxo() != null) {
postData += "&nom_referentiel="+URL.encodeComponent(""+obs.getReferentielTaxo());
}
 
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
if(observationModele != null) {
observationModele.obtenirListeObservation(r);
}
}
}) ;
} catch (RequestException e) {
}
}
 
/**
* Supprime les observations possédant les identifiants données
* @param r le rafraichissable à avertir de la mise à jour
* @param identifiant l'identifiant utilisateur
* @param numerosOrdre les numéros d'ordre des observations séparés par des virgules
*/
public void supprimerListeObservation(Rafraichissable r, String identifiant, String numerosOrdre) {
String postData = "";
postData += "&action=DELETE";
 
// on envoie un post avec l'id de l'image à supprimer
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.POST,
Configuration.getServiceBaseUrl()
+ "/inventoryObservationList/"
+ identifiant
+ "/"
+ numerosOrdre);
try {
rb.sendRequest(postData, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
 
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
 
if (response.getText().equals("OK")) {
 
} else {
com.google.gwt.user.client.Window
.alert("Problème lors de la mise à jour des données");
return ;
}
}
});
r.rafraichir("OK", true) ;
 
} catch (RequestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/modeles/dao/NombreObservationAsynchroneDAO.java
New file
0,0 → 1,112
package org.tela_botanica.client.modeles.dao;
 
import org.tela_botanica.client.image.ImageModele;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.observation.ObservationModele;
 
import com.google.gwt.http.client.Request;
import org.tela_botanica.client.util.RequestBuilderWithCredentials;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
 
/**
* DAO qui renvoie le nombre d'image associées à différents critères donnés (utile pour la pagination)
* @author aurelien
*
*/
public class NombreObservationAsynchroneDAO {
 
 
/**
* Le modèle associé au DAO
*/
private ObservationModele observationModele = null ;
private ImageModele imageModele = null;
public NombreObservationAsynchroneDAO(ObservationModele observationModele)
{
this.observationModele=observationModele;
}
 
public NombreObservationAsynchroneDAO(final ImageModele imageModele) {
this.imageModele = imageModele;
}
/**
* Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant
* à des critères données en paramètres
* @param r le rafraichissable qui demande la mise à jour
* @param criteres un tableau nom/valeur des critères pour les images
*/
public void obtenirNombreObservation(final Rafraichissable r, String utilisateur, String[][] criteres)
{
String requete = "" ;
if(criteres != null)
{
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...)
for (int i = 0; i < criteres.length; i++) {
 
if(criteres[i][1] != null && !criteres[i][1].equals(""))
{
if(i!= 0)
{
requete += "&";
}
requete += criteres[i][0]+"="+URL.encodeComponent(criteres[i][1]) ;
}
}
}
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()+"/InventoryObservationCount/"+utilisateur+"/?"+requete) ;
try {
rb.sendRequest(null, new RequestCallback() {
 
@Override
public void onError(Request request, Throwable exception) {
// TODO Auto-generated method stub
}
 
@Override
public void onResponseReceived(Request request,
Response response) {
final JSONValue responseValue = JSONParser.parse(response.getText());
// si la requete se passe bien on reçoit un tableau JSON
if(responseValue.isString() != null)
{
// qui contient une valeur : le nombre d'images correspondant au critères
JSONString res = responseValue.isString() ;
int maxObservations = Integer.parseInt(res.stringValue()) ;
int[] nbObservations = {maxObservations} ;
 
// on le met dans un tableau d'entiers qu'on tranmset au demandeur de la mise à jour
r.rafraichir(nbObservations, true) ;
} else {
int[] nbObservations = {} ;
r.rafraichir(nbObservations, true) ;
}
}
}) ;
} catch (RequestException e) {
}
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/observation/ObservationMediateur.java
New file
0,0 → 1,1252
package org.tela_botanica.client.observation;
 
 
 
// TODO : systematiser les onQuelquechose, appelle depuis les vues
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.InfosReferentielNom;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.vues.observation.CartographieObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue;
import org.tela_botanica.client.vues.observation.ListeObservationVue;
import org.tela_botanica.client.vues.observation.MenuObservationVue;
import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues;
import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue;
import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue;
import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue;
import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.History;
import com.google.gwt.user.client.Window;
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.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
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.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
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
*
*/
public class ObservationMediateur {
/**
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false ;
 
/**
* pointeur sur le médiateur (pour le pattern singleton)
*/
private static ObservationMediateur thisMediateur = null ;
/** Mediateur general de l'application carnet en ligne
*
*
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* modele de données
*/
private ObservationModele observationModele = null ;
/**
* panneau principal des Observation (onglet "observation")
*/
private final Panel panneauPrincipalObservation = new Panel("Observations");
/**
* liste détaillée des Observations
*/
public ListeObservationVue listeObservation = null ;
/**
* Saisie des Observations
*/
private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
/**
*
* Import des observations depuis un fichier
*
*/
private FormulaireImportObservationVue formImportObs=null;
/**
* Cartographie
*/
private CartographieObservationVue cartoObservationVue = null;
 
/**
* booleen explicitant s'il y a une selection en cours
*/
private boolean selection = false ;
/**
* panneau conteneur pour le panneau des informations lies à l'observation
*/
private Panel details = new Panel("Details");
 
private LienExterneVue liExtVue = null;
 
/**
* panneau conteneur pour le panneau des filtres
*/
private PanneauFiltresObservationVues filtres = null;
 
/**
* panneau d'information de repartition sur le nom selectionné
*
*/
private InformationRepartitionVue informationRepartitionVue=null;
/**
* panneau d'affichage d'une image generique associe au nom selectionne
*
*/
private ImageGeneriqueVue imageGeneriqueVue=null;
private MiniZoomImageVue mvz = null ;
private boolean importerObservations = false ;
 
private com.gwtext.client.widgets.Window fenetreCarto;
public boolean changementTabProg = false;
private InfosReferentielNom refTaxSelectionne = null;
 
private Panel centre;
/**
* constructeur privé (on accède a la classe par la méthode getInstance
*/
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
{
this.carnetEnLigneMediateur=carnetEnLigneMediateur;
// on crée un modèle
observationModele = ObservationModele.Instance(this);
// initialisation du référentiel par défaut
setRefTaxSelectionne(Configuration.getReferentielsDispos().get(0));
listeObservation = new ListeObservationVue(this);
listeObservation.setTitle("Observations");
// quelques variables de position pour les borderlayouts
final BorderLayoutData regionNord = new BorderLayoutData(
RegionPosition.NORTH);
 
final BorderLayoutData regionCentre = new BorderLayoutData(
RegionPosition.CENTER);
regionCentre.setSplit(true);
 
final BorderLayoutData regionEst = new BorderLayoutData(
RegionPosition.EAST);
regionEst.setSplit(true);
 
final BorderLayoutData regionOuest = new BorderLayoutData(
RegionPosition.WEST);
regionOuest.setSplit(true);
panneauPrincipalObservation.setLayout(new BorderLayout()) ;
cartoObservationVue = new CartographieObservationVue(this);
cartoObservationVue.setLayout(new FitLayout());
// Le formulaire de saisie / modification d'observation
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
formulaireSaisieObservationVue.setTitle("Saisie");
formulaireSaisieObservationVue.setTitleCollapse(true);
formulaireSaisieObservationVue.setCollapsible(true) ;
formulaireSaisieObservationVue.setAutoScroll(true) ;
fenetreCarto = new com.gwtext.client.widgets.Window();
fenetreCarto.setConstrain(true);
fenetreCarto.setModal(true);
fenetreCarto.setCloseAction(com.gwtext.client.widgets.Window.HIDE);
fenetreCarto.add(cartoObservationVue);
formulaireSaisieObservationVue.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
});
centre = new Panel();
centre.setLayout(new BorderLayout());
centre.setAutoScroll(true);
centre.setBorder(false);
centre.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onResize(BoxComponent component, int adjWidth,
int adjHeight, int rawWidth, int rawHeight) {
formulaireSaisieObservationVue.redimensionnerFormulaire();
listeObservation.doLayout();
}
@Override
public void onAfterLayout(Container self) {
}
});
formulaireSaisieObservationVue.setBorder(false);
BorderLayoutData listeLayoutData = new BorderLayoutData(RegionPosition.SOUTH);
listeLayoutData.setSplit(true);
BorderLayoutData formLayoutData = new BorderLayoutData(RegionPosition.CENTER);
formLayoutData.setSplit(true);
centre.add(listeObservation, listeLayoutData);
centre.add(formulaireSaisieObservationVue, formLayoutData);
 
// Redimensionnement global sur collapse/expand
details.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
String[] selectionListe = listeObservation.getIdSelectionnees();
if(selectionListe.length > 0) {
Observation obs = listeObservation.getCacheListeObservation().get(selectionListe[0]);
obtenirImageInformationExternes(obs.getCodeCourtReferentielTaxo(), obs.getNumeroNomenclaturalSaisi());
}
CarnetEnLigneMediateur.fireResize();
}
});
// on initialise le volet qui contient les details
details.setWidth("10%");
details.setTitleCollapse(true);
details.setCollapsible(true);
details.setAutoScroll(true);
details.setLayout(new RowLayout());
// Lien vers eflore
liExtVue = new LienExterneVue(this);
liExtVue.setHeight("20px");
details.add(liExtVue);
// Information de repartition
informationRepartitionVue=new InformationRepartitionVue(this);
details.add(informationRepartitionVue, new RowLayoutData("30%"));
// Image generique
imageGeneriqueVue=new ImageGeneriqueVue(this);
details.add(imageGeneriqueVue, new RowLayoutData("30%"));
mvz = new MiniZoomImageVue(this) ;
details.add(mvz, new RowLayoutData("34%")) ;
// on crée le panneau des filtres
filtres = new PanneauFiltresObservationVues(this);
// on initialise le volet qui contient les filtres
filtres.setWidth("10%");
filtres.setTitleCollapse(true);
filtres.setCollapsible(true);
filtres.addListener(
new PanelListenerAdapter() {
@Override
public void onCollapse(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
@Override
public void onExpand(Panel panel) {
CarnetEnLigneMediateur.fireResize();
}
});
panneauPrincipalObservation.add(details,regionEst);
panneauPrincipalObservation.add(filtres,regionOuest);
panneauPrincipalObservation.add(centre,regionCentre);
}
/**
* Retourne une instance de manière unique
* @return l'instance unique du médiateur
*/
public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
{
if(!estInstancie || thisMediateur == null)
{
estInstancie = true ;
thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
}
return thisMediateur ;
}
public void connecterUtilisateur() {
if(importerObservations) {
observationModele.importerObservations();
}
if(panneauPrincipalObservation == null || !panneauPrincipalObservation.isCreated())
{
panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
{
@Override
public void onRender(Component c)
{
panneauPrincipalObservation.purgeListeners() ;
initialiserArbres();
filtres.getRechercheLibreVue().raz();
obtenirNombreObservation();
analyserHistorique();
}
}) ;
}
else
{
initialiserArbres();
filtres.getRechercheLibreVue().raz();
obtenirNombreObservation();
analyserHistorique();
}
}
private void initialiserArbres() {
getPanneauFiltres().getArbreDateObservationFiltreVue().initialiser();
getPanneauFiltres().getArbreEntiteGeographiqueObservationFiltreVue().initialiser();
getPanneauFiltres().getArbreMotsClesObservationVue().initialiser();
}
 
// ACTIONS a entreprendre lors d'un evenement particulier
/**
* Lors du raffraichissement de la liste d'observation
*/
public void onRafraichissementListeObservations() {
carnetEnLigneMediateur.donneesObsVersImages(listeObservation.getCacheListeObservation());
observationModele.rafraichirCacheObservation(listeObservation.getCacheListeObservation());
filtres.getArbreMotsClesObservationVue().cocherMotsCles(new String[0]);
}
/**
*
* TODO : fonction plus generique, appelle sur un clic ou une selection de ligne, a appeller : SelectionnerObservation
* 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 onClicListeObservation(int rowIndex, String ordreObservation) {
Observation obs = obtenirCacheObservation().get(ordreObservation) ;
if(GWT.isScript()) {
masquerChargementInfosObservations() ;
}
gererMiseAJourFormulaireObservation();
gererMiseAJourPanneauDetails(obs);
}
public void gererMiseAJourPanneauDetails(Observation obs) {
// Affichage de l'image correspondante
if(details.isVisible()) {
// Affichage de la carte de repartition correspondante
String numeroNomenclaturalSaisiObservation = obs.getNumeroNomenclaturalRetenu();
if(numeroNomenclaturalSaisiObservation != null && !numeroNomenclaturalSaisiObservation.isEmpty()) {
observationModele.obtenirImageInformationRepartition(informationRepartitionVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
observationModele.obtenirImageGenerique(imageGeneriqueVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
} else {
informationRepartitionVue.rafraichir("", false);
imageGeneriqueVue.rafraichir("", false);
}
observationModele.obtenirLiaisonImage(mvz, obs.getId()) ;
String[] infosRafraichissementLienExterne = {numeroNomenclaturalSaisiObservation, obs.getReferentielTaxo()};
liExtVue.rafraichir(infosRafraichissementLienExterne, false);
}
filtres.getArbreMotsClesObservationVue().rafraichir(obs.getMotsCles(), false);
}
public void gererMiseAJourFormulaireObservation() {
String[] ids = listeObservation.getIdSelectionnees();
if(ids.length == 1) {
Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length - 1]);
// affichage des détails dans le formulaire d'observation
formulaireSaisieObservationVue.rafraichir(obs, false) ;
} else {
ListeObservation listeObs = new ListeObservation();
for(int i=0; i < ids.length;i++) {
Observation obsAjout = observationModele.getCacheObservation().get(ids[i]);
listeObs.ajouterObservation(obsAjout);
}
formulaireSaisieObservationVue.rafraichir(listeObs, false);
}
}
public void obtenirImageInformationExternes(String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
if(details.isVisible()) {
if(GWT.isScript()) {
masquerChargementInfosObservations() ;
}
liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
observationModele.obtenirImageInformationRepartition(informationRepartitionVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
observationModele.obtenirImageGenerique(imageGeneriqueVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
}
}
public int getTaillePage() {
return listeObservation.getTaillePage();
}
public int getPageEnCours() {
return listeObservation.getPageEncours();
}
// ACCES au Modèle
// C du CRUD
/**
* TODO : afficher un message du type "observation ajouté".
* Lance la creation d'une observation
* @param obs : l'observation saisie
*/
public void ajouterObservation(Observation obs) {
// On rafraichit la liste d'observation
observationModele.ajouterObservation(listeObservation, obs) ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
}
// R du CRUD
/**
* Demande au modele le nombre d'Observation à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirNombreObservation() {
listeObservation.masquerChargement() ;
mvz.raz() ;
imageGeneriqueVue.raz() ;
informationRepartitionVue.raz() ;
observationModele.obtenirNombreObservation(listeObservation) ;
}
/**
* Demande au modele le nombre d'Observation à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirDernierePageObservation() {
listeObservation.rafraichir(new Observation(),false) ;
}
 
public void obtenirListeObservation() {
obtenirListeObservation(listeObservation);
}
/**
* Demande au modele le detail des Observations à afficher
* TODO : grouper cette demande avec la demande d'affichage de liste ?
*/
 
public void obtenirListeObservation(Rafraichissable r) {
listeObservation.masquerChargement() ;
observationModele.obtenirListeObservation(r,listeObservation.getTaillePage(),listeObservation.getPageEncours()) ;
}
public void obtenirCacheObservation(Rafraichissable r) {
r.rafraichir(observationModele.getCacheObservation(), false) ;
}
 
/**
* Envoie au modèle une demande pour obtenir l'arbre des localites
*
* @param r
* le raffraichissable qui a demandé la mise à jour
*/
public void obtenirListeEntiteGeographique() {
observationModele.obtenirListeEntiteGeographique(filtres.getArbreEntiteGeographiqueObservationFiltreVue());
}
// U du CRUD
public void modifierObservation(Observation obs) {
// On prend soin de récupérer les mots clés de l'observation
Observation obsMod = obtenirCacheObservation().get(obs.getNumeroOrdre());
obs.setMotsCles(obsMod.getMotsCles());
// On rafraichit la liste d'observation
observationModele.modifierObservation(listeObservation, obs) ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
}
public void modifierObservationEnMasse(Observation obs) {
// On rafraichit la liste d'observation
listeObservation.masquerChargement();
observationModele.modifierObservationEnMasse(listeObservation, obs) ;
}
// D du CRUD
/**
* TODO : afficher un message du type "observation modifie".
* Lance la modification d'une observation
* @param obs : l'observation a modifier
*/
public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
if(listeObservation.getSelectionModel().getCount() > 0)
{
if(Window.confirm("Êtes vous sur de vouloir supprimer cette observation ?")) {
observationModele.supprimerObservation(r,numeroOrdre) ;
}
}
}
public boolean listeAvoirObservations() {
return listeObservation.getStore().getCount() > 0;
}
// Assistants de saisie
/**
*
* Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
observationModele.obtenirListeReferentielCommune(r,critere) ;
}
// Assistants de saisie
/**
*
* Lance un appel de recherche d'une liste de résultats
* correspondant aux criteres de selections pour un référentiel donné
* @param r : la vue demandeuse de donnee
* @param referentiel : le référentiel demandé
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
observationModele.obtenirListeReferentielPerso(r, referentiel, critere) ;
}
/**
*
* Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielNom(Rafraichissable r,String referentiel, String critere) {
 
observationModele.obtenirListeReferentielNom(r, referentiel, critere) ;
}
// Etat du syteme
/**
* 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()
{
int longueur = 0;
String[] filtresEntitesGeo = filtres.getArbreEntiteGeographiqueObservationFiltreVue().renvoyerValeursAFiltrer() ;
String chaineNomsFiltresGeo = filtresEntitesGeo[0] ;
String chaineValFiltresGeo = filtresEntitesGeo[1] ;
String[] filtresDate = filtres.getArbreDateObservationFiltreVue().renvoyerValeursAFiltrer() ;
String chaineNomsFiltresDate = filtresDate[0] ;
String chaineValFiltresDate = filtresDate[1] ;
String[] filtresTaxon = filtres.getRechercheLibreVue().renvoyerValeursAFiltrer();
String[] filtresMotsCles = filtres.getArbreMotsClesObservationVue().renvoyerValeursAFiltrer();
String chaineNomsFiltres = "" ;
String chaineValFiltres = "" ;
if(!chaineNomsFiltresGeo.trim().equals("") && !chaineValFiltresGeo.trim().equals("")) {
chaineNomsFiltres += chaineNomsFiltresGeo+",";
chaineValFiltres += chaineValFiltresGeo+",";
}
if(!chaineNomsFiltresDate.trim().equals("") && !chaineValFiltresDate.trim().equals("")) {
chaineNomsFiltres += chaineNomsFiltresDate+",";
chaineValFiltres += chaineValFiltresDate+",";
}
if(!filtresTaxon[0].trim().equals("") && !filtresTaxon[1].trim().equals("")) {
chaineNomsFiltres += filtresTaxon[0]+",";
chaineValFiltres += filtresTaxon[1]+",";
}
if(!filtresMotsCles[0].trim().equals("") && !filtresMotsCles[1].trim().equals("")) {
chaineNomsFiltres += filtresMotsCles[0];
chaineValFiltres += filtresMotsCles[1];
}
String[] nomsFiltres = chaineNomsFiltres.split(",") ;
String[] valsFiltres = chaineValFiltres.split(",") ;
longueur += nomsFiltres.length;
String [][] valeursFiltres = new String[longueur][2] ;
int i = 0;
if(valsFiltres.length > 0)
{
for(i = 0 ; i < nomsFiltres.length ; i++)
{
valeursFiltres[i][0] = nomsFiltres[i] ;
if(valsFiltres[i].equals("Inconnue"))
{
valeursFiltres[i][1] = "NULL" ;
}
else
{
valeursFiltres[i][1] = valsFiltres[i] ;
}
}
}
listeObservation.afficherFiltres(valeursFiltres) ;
return valeursFiltres ;
}
 
/**
*
* @return
*
*/
public Panel getPanneauPrincipalObservation() {
return panneauPrincipalObservation;
}
 
 
public void montrerContextMenu(EventObject e) {
MenuObservationVue mvo = new MenuObservationVue(this) ;
mvo.showAt(e.getXY()) ;
}
 
public void doubleClicListeObservation(int rowIndex) {
}
// Getters
public PanneauFiltresObservationVues getPanneauFiltres() {
return filtres;
}
public void masquerChargementInfosObservations()
{
ExtElement masked = Ext.get(details.getId());
 
if (details.isVisible() && masked != null) {
informationRepartitionVue.raz() ;
imageGeneriqueVue.raz() ;
masked.mask("Chargement", true);
}
 
cartoObservationVue.masquerChargement(true);
}
public void deMasquerChargementInfosObservations()
{
ExtElement masked = Ext.get(details.getId());
 
if (details.isVisible() && masked != null) {
masked.unmask() ;
}
}
 
 
public void obtenirDatesObservation() {
observationModele.obtenirDatesObservation(filtres.getArbreDateObservationFiltreVue()) ;
}
 
 
public void exporterObservations(String format, String colonnes) {
observationModele.exporterObservations(format, colonnes) ;
}
 
public void exporterObservationsPDF() {
if(listeObservation.getIdSelectionnees().length > 300) {
// com.google.gwt.user.client
Window.alert("Les étiquettes ne peuvent être générées pour plus de 300 observations d'un coup.");
return;
}
// TODO: nombre en fonction des filtres actifs, combien d'éléments seraient envoyés ?
if(listeObservation.getIdSelectionnees().length == 0) {
//import com.google.gwt.core.client.GWT.log( XXX éléments);
}
observationModele.exporterObservationsPDF(listeObservation.getIdSelectionnees());
}
 
 
public void deconnecterUtilisateur() {
if(panneauPrincipalObservation == null || panneauPrincipalObservation.isCreated() || !panneauPrincipalObservation.isVisible())
{
panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
{
@Override
public void onShow(Component component)
{
deconnecterUtilisateur();
panneauPrincipalObservation.purgeListeners();
}
});
}
else
{
listeObservation.raz() ;
formulaireSaisieObservationVue.raz() ;
razFiltres();
informationRepartitionVue.raz() ;
imageGeneriqueVue.raz() ;
mvz.raz() ;
}
}
 
 
public void supprimerLiaisonObsImage() {
String ordreObs = listeObservation.getIdSelectionnees()[0];
String idObs = observationModele.getIdPourOrdreObs(ordreObs);
String idImg = mvz.getIdImage() ;
if(Window.confirm("Supprimer le lien entre l'image "+idImg+" et l'observations "+idObs+" ?"))
{
mvz.supprimerLiaisonImage() ;
observationModele.supprimerLiaisonImages(idImg,idObs) ;
}
}
 
public void supprimerObservations() {
if(listeObservation.getIdSelectionnees().length > 0) {
if(Window.confirm("Êtes vous sur de vouloir supprimer les observations sélectionnées ?")) {
String[] numObs = listeObservation.getIdSelectionnees();
String numObsapl = "" ;
for(int i = 0 ; i < numObs.length ; i++) {
numObsapl += numObs[i]+"," ;
}
observationModele.supprimerListeObservation(listeObservation,numObsapl) ;
}
}
else
{
Window.alert("Aucune observation sélectionnée");
}
}
 
 
public void transmettreObservations(boolean publier) {
if(Utilisateur.getInstance().isIdentifie()) {
if(listeObservation.getIdSelectionnees().length > 0) {
String action = "" ;
if(publier) {
action = "rendre publiques" ;
}
else {
action = "rendre privées" ;
}
if(Window.confirm("Êtes vous sur de vouloir "+action+" les observations sélectionnées ?")) {
String[] numObs = listeObservation.getIdSelectionnees();
String numObsApl = "" ;
for(int i = 0 ; i < numObs.length ; i++) {
numObsApl += numObs[i] ;
if(i != numObs.length - 1) {
numObsApl +="," ;
}
}
observationModele.transmettreListeObservation(listeObservation,numObsApl, publier) ;
}
}
else
{
Window.alert("Aucune observation sélectionnée");
}
}
else
{
if(publier) {
if(Window.confirm("La publication des observations nécessite d'être identifié, voulez-vous vous identifier ? (toutes vos observations saisies seront conservées)")) {
importerObservations = true ;
carnetEnLigneMediateur.afficherDialogueConnexion();
}
}
}
}
public void analyserHistorique() {
if (History.getToken().length()>0) {
 
final String anum=History.getToken();
observationModele.analyserHistorique(formulaireSaisieObservationVue,anum);
}
}
 
/**
* 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) {
 
observationModele.mettreAjourMotsClesId(text, id);
 
}
public boolean gererDDObsSurMotCle(TreeNode NoeudMotCle, DragData dragData) {
if(dragData instanceof GridDragData) {
 
GridDragData gdd = ((GridDragData)dragData);
String idMotCle = ((String[])NoeudMotCle.getUserObject())[1];
Record[] obsALier = gdd.getSelections();
String idObsALier[] = new String[obsALier.length];
String idObsALierString = "";
for(int i = 0; i < obsALier.length; i++) {
if(i != 0) {
idObsALierString += ", ";
}
idObsALierString += obsALier[i].getAsString("ordre_observation");
if(!observationAvoirMotCle(idMotCle, obsALier[i].getAsString("ordre_observation"))) {
idObsALier[i] = obsALier[i].getAsString("ordre_observation");
} else {
idObsALier[i] = "";
}
}
String message = "Lier les observations ";
if(idObsALier.length == 1) {
message = "Lier l'observation ";
}
if(Window.confirm(message+idObsALierString+" au projet "+NoeudMotCle.getText()+" ?")) {
mettreAjourMotsCles(idMotCle, idObsALier);
return true;
} else {
return false;
}
} else {
return false;
}
}
public void gererDDMotCleSurObs(String idObs, String idMC) {
Observation obs = obtenirCacheObservation().get(idObs);
if(obs == null) {
return;
}
if(observationAvoirMotCle(idMC, idObs)) {
if(Window.confirm("Voulez vous supprimer la liaison entre l'observation et le mot clé ?")) {
String nouveauMotsCles = obs.getMotsCles().replace(idMC, "");
nouveauMotsCles = nouveauMotsCles.replace(";;", ";");
obs.setMotsCles(nouveauMotsCles);
observationModele.supprimerLiaisonMotCleObservations(listeObservation, obs.getId(), idMC);
}
}
}
 
public String gererOverDDMotCleSurObs(String idObs, String IdMC) {
if(observationAvoirMotCle(IdMC, idObs)) {
return "x-dd-drop-unlink";
} else {
return "x-dd-drop-nodrop";
}
}
/**
* Récupère les identifiants des obs selectionnézs et appelle le modèle
* pour qu'il mette à jour les associations mots clés/obs
*
* @param motsClesEnCours
* les mots clés à associer aux images selectionnés séparés par
* un ';'
* @param arbreMC
* l'arbre des mots clés à mettre à jour
*/
public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
String[] ids = listeObservation.getIdSelectionnees();
observationModele.mettreAjourMotsCles(motsClesEnCours, idsObsALier);
 
}
 
/**
* 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, Rafraichissable r) {
observationModele.ajouterMotCleDansArbre(n, arbreMC, r);
}
 
/**
* 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, Rafraichissable r) {
observationModele.supprimerMotCleDansArbre(n, arbreMC, r);
}
 
/**
* 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) {
observationModele.modifierMotCleDansArbre(n, arbreMC, getPanneauFiltres().getArbreMotsClesObservationVue());
}
 
/**
* 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) {
 
observationModele.deplacerMotCleDansArbre(n, arbreMC, getPanneauFiltres().getArbreMotsClesObservationVue());
}
 
 
public void rafraichirArbreMotsCles(Tree arbreMotsCles) {
getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(arbreMotsCles, false);
}
public boolean observationAvoirMotCle(String idMotCle, String idObs) {
Observation obs = obtenirCacheObservation().get(idObs);
if(obs == null) {
return false;
}
if(obs.getMotsCles().contains(idMotCle)) {
return true;
}
return false;
}
 
 
public void obtenirArbreMotsCles(Rafraichissable r) {
observationModele.obtenirArbreMotsCles(r);
}
public String[] obtenirTexteMotsCles(String[] idsMotsCles) {
String[] tableauMotsClesTexte = new String[idsMotsCles.length];
for(int i=0; i< idsMotsCles.length; i++) {
tableauMotsClesTexte[i] = observationModele.obtenirTexteMotCle(idsMotsCles[i]);
}
return tableauMotsClesTexte;
}
public ListeObservation obtenirCacheObservation() {
return observationModele.getCacheObservation();
}
 
public void donneesExterieures(Object nouvelleDonnees) {
if(nouvelleDonnees instanceof Tree) {
Tree arbreMotsCles = (Tree)nouvelleDonnees ;
observationModele.rafraichirArbreMotsCles(nouvelleDonnees);
rafraichirArbreMotsCles(arbreMotsCles);
}
}
public void transmettreDonnees(Object o) {
carnetEnLigneMediateur.donneesObsVersImages(o);
}
public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
observationModele.obtenirInformationCoord(r, lat, lng);
}
public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
observationModele.obtenirInformationCommune(r,nomCommune, codePostal);
}
 
public void obtenirInformationCoord(double lat, double lng) {
this.obtenirInformationCoord(lat, lng, false);
}
 
public void obtenirInformationCoord(double lat, double lng, boolean zoomer) {
cartoObservationVue.setDoitZoomerSurRetour(true);
observationModele.obtenirInformationCoord(cartoObservationVue, lat, lng);
}
 
public void obtenirInformationCommune(String nomCommune,
String codePostal) {
observationModele.obtenirInformationCommune(cartoObservationVue,nomCommune, codePostal);
}
 
public void rafraichirSaisieCommuneObservation(EntiteGeographiqueObservation infosCommune) {
formulaireSaisieObservationVue.rafraichir(infosCommune, false);
cacherFenetreCarto();
}
 
private void razFiltres() {
filtres.getArbreDateObservationFiltreVue().raz() ;
filtres.getArbreEntiteGeographiqueObservationFiltreVue().raz() ;
filtres.getArbreMotsClesObservationVue().raz();
filtres.getRechercheLibreVue().raz();
}
 
public void viderFiltre(String nom) {
filtres.viderFiltres(nom);
obtenirNombreObservation();
}
 
public Component getListeObservation() {
return listeObservation;
}
 
public void redimensionnerPanneaux(int adjHeight, int adjWidth) {
formulaireSaisieObservationVue.setHeight(300);
listeObservation.setHeight(adjHeight/2);
centre.doLayout();
}
 
public void afficherFormulaireImportObservation() {
if (formImportObs==null) { // lazy inst.
formImportObs = new FormulaireImportObservationVue(this);
}
formImportObs.afficher();
}
 
public void setImporterObservationsAnonymes(boolean importerObservations) {
this.importerObservations = importerObservations;
}
 
private void localiserSurCommuneSelectionnee() {
cartoObservationVue.masquerChargement(true);
double[] coordsTab = formulaireSaisieObservationVue.coordonneesValides();
if(formulaireSaisieObservationVue.coordonneesValides() != null && !formulaireSaisieObservationVue.getCommune().equals("")) {
String nomCommune = formulaireSaisieObservationVue.getCommuneSansDepartement();
String dptCommune = formulaireSaisieObservationVue.getDepartement();
EntiteGeographiqueObservation egeo = new EntiteGeographiqueObservation(dptCommune, nomCommune, "","");
egeo.setLat(coordsTab[0]+"");
egeo.setLon(coordsTab[1]+"");
cartoObservationVue.rafraichir(egeo, false);
} else {
if(formulaireSaisieObservationVue.coordonneesValides() != null) {
obtenirInformationCoord(coordsTab[0],coordsTab[1]);
} else if (formulaireSaisieObservationVue.communeInitialisee()) {
String nomCommune = formulaireSaisieObservationVue.getCommune();
String dptCommune = formulaireSaisieObservationVue.getDepartement();
obtenirInformationCommune(nomCommune, dptCommune);
} else {
double[] coordsCentreFrance = cartoObservationVue.getCoordsCentreFrance();
obtenirInformationCoord(coordsCentreFrance[0], coordsCentreFrance[1]);
}
}
}
 
public void afficherFenetreCarto() {
int hauteur = (int)Math.round(Window.getClientHeight()*0.75);
int largeur = (int)Math.round(Window.getClientWidth()*0.75);
fenetreCarto.setSize(largeur, hauteur);
if(!fenetreCarto.isVisible()) {
fenetreCarto.show();
}
cartoObservationVue.setTailleCarte(hauteur - 20, largeur - 20);
}
 
private void cacherFenetreCarto() {
if(fenetreCarto.isVisible()) {
fenetreCarto.hide();
}
}
 
public InfosReferentielNom getRefTaxSelectionne() {
return refTaxSelectionne;
}
public void setRefTaxSelectionne(int index) {
refTaxSelectionne = Configuration.getReferentielsDispos().get(index);
}
public void setRefTaxSelectionne(InfosReferentielNom refTax) {
refTaxSelectionne = refTax;
}
 
public String renvoyerTri() {
return listeObservation.renvoyerTri();
}
 
public String renvoyerDirectionTri() {
return listeObservation.renvoyerDirectionTri();
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/observation/ObservationModele.java
New file
0,0 → 1,701
package org.tela_botanica.client.observation;
 
 
//TODO : normaliser les noms de methodes (obtenir, ajouter ...)
 
import java.util.HashMap;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ExportObservationsDAO;
import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.InformationCommuneDAO;
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielCommuneAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.util.MotsClesUtilitaire;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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 ObservationModele 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 ObservationModele thisModele = null ;
/**
* La configuration en cours
*/
private Configuration config = null;
 
/**
* Le médiateur associé au modèle
*/
private ObservationMediateur observationMediateur = null ;
/**
* La liste des mots clés en cours
*/
private HashMap<String, String> motsCles = new HashMap<String, String>(0);
private Tree arbreMotsCles = new Tree() ;
/**
* La liste des observations affichées en cours (verifier utilité)
*/
private ListeObservation cacheObservation = new ListeObservation(0) ;
/**
* DAO dont le resultat peut etre mis en cache
*
*/
private ListeReferentielNomAsynchroneDAO nomDAO=null;
private ListeReferentielCommuneAsynchroneDAO refDAO=null;
private ListeReferentielPersoAsynchroneDAO refPersoDAO=null;
 
/**
* Retourne une instance de manière unique
* @param im le médiateur à associer
* @return l'instance du modèle
*/
static ObservationModele Instance(ObservationMediateur observationMediateur)
{
// si le modèle n'est pas encore instancié
if(!estInstancie)
{
// on en crée un nouveau
estInstancie = true ;
thisModele = new ObservationModele(observationMediateur);
}
return thisModele ;
}
 
private ObservationModele(ObservationMediateur observationMediateur) {
this.observationMediateur=observationMediateur;
config = new Configuration();
 
}
 
/**
* Appelle le DAO asynchrone pour obtenir le nombre d'observation
* @param r le rafraichissable auxquel on enverra les données
* @param filtrage
* @param taillePage
*/
public void obtenirNombreObservation(Rafraichissable r) {
String[][] criteres = {{"",""}} ;
criteres = observationMediateur.renvoyerFiltres() ;
// on rassemble les critères
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ;
noaDAO.obtenirNombreObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ;
}
public void obtenirListeObservation(Rafraichissable r) {
obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours());
}
/**
* Appelle le DAO asynchrone pour obtenir la liste des images
* @param r le rafraichissable auxquel on enverra les données
* @param taillePage
*/
public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) {
String[][] criteres = {{"",""}} ;
criteres = observationMediateur.renvoyerFiltres() ;
// on rassemble les critères
// ensuite on demande la page correspondante avec les mêmes critères
String[][] criteres2 = new String[criteres.length+4][2] ;
criteres2[0][0] = "limite" ;
criteres2[0][1] = ""+taillePage ;
criteres2[1][0] = "numero_page" ;
criteres2[1][1] = ""+pageEncours ;
criteres2[2][0] = "tri" ;
criteres2[2][1] = ""+observationMediateur.renvoyerTri();
criteres2[3][0] = "tri_dir";
criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ;
for(int i = 0 ; i < criteres.length ; i++)
{
criteres2[i+4][0] = criteres[i][0] ;
criteres2[i+4][1] = criteres[i][1] ;
}
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
loaDAO.obtenirListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2);
}
 
/**
* Obtenir une liste de commune
* @param r
* @param critere
*/
public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
if (refDAO==null) {
refDAO=new ListeReferentielCommuneAsynchroneDAO(this);
}
refDAO.obtenirListeDonnees(r, critere);
}
/**
* Obtenir une liste de commune
* @param r
* @param critere
*/
public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
if (refPersoDAO==null) {
refPersoDAO=new ListeReferentielPersoAsynchroneDAO(this);
}
refPersoDAO.setRefDemande(referentiel);
refPersoDAO.obtenirListeDonnees(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), critere);
}
/**
* Obtenir une liste de nom scientifique de plante
* @param r
* @param critere
*/
public void obtenirListeReferentielNom(Rafraichissable r, String referentiel, String critere) {
if (nomDAO==null) {
nomDAO=new ListeReferentielNomAsynchroneDAO(this);
}
nomDAO.obtenirListeDonnees(r, referentiel, critere);
}
/**
*
* Lance la creation d'une observation
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void ajouterObservation(Rafraichissable r, Observation obs) {
ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
obsDAO.ajouter(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
}
 
/**
*
* Lance la creation d'une observation
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void modifierObservation(Rafraichissable r, Observation obs) {
ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this);
obsDAO.modifier(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
}
 
 
public void modifierObservationEnMasse(
Rafraichissable r, Observation obs) {
ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this);
liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs);
}
 
 
public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ;
obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),numeroOrdre) ;
}
 
 
/**
* Accesseur pour la configuration en cours d'utilisation
*
* @return la configuration
*/
public Configuration getConfig() {
 
return config;
}
 
/**
* Obtenir des informations de repartition relative a un numero nomenclatural
* @param r
* @param numeroNomenclaturalSaisiObservation
*/
 
 
public void obtenirImageInformationRepartition(Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this);
repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
}
 
/**
* Obtenir une image generique associee a un numero nomenclatural
* @param r
* @param numeroNomenclaturalSaisiObservation
*/
 
public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this);
imgDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation);
}
 
 
/**
* Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur
* @param r
*/
 
public void obtenirListeEntiteGeographique(Rafraichissable r) {
 
ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this);
entDAO.obtenirListeEntitesGeographiques(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
 
}
 
 
 
public void obtenirDatesObservation(
Rafraichissable r) {
ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this);
ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
}
 
 
 
public void obtenirLiaisonImage(Rafraichissable r,
String idObservation) {
LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ;
liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ;
}
 
 
 
public void exporterObservations(String format, String groupes) {
String[][] criteres = {{"",""}} ;
criteres = observationMediateur.renvoyerFiltres();
// on rassemble les critères
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ;
}
 
public void exporterObservationsPDF(String[] ordres) {
String[][] criteres = {{"",""}} ;
criteres = observationMediateur.renvoyerFiltres();
String ids = "";
for (int j = 0; j < ordres.length; j++) {
ids += getIdPourOrdreObs(ordres[j]) + ",";
}
 
String[] fmt = {"obsids", ids};
String[][] tous_criteres = new String[criteres.length + 1][];
System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length);
tous_criteres[tous_criteres.length - 1] = fmt;
 
ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ;
exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ;
}
 
 
 
public void supprimerLiaisonImages(String idImg, String idObs) {
LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
lienDAO.supprimerLienImageObservation(idImg, idObs) ;
}
 
public void supprimerListeObservation(Rafraichissable r,
String numObs) {
ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this);
lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs);
}
 
public void transmettreListeObservation(
Rafraichissable r, String numObsapl, boolean publier) {
TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this);
toaDAO.transmettreObservations(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObsapl, publier);
}
 
public void analyserHistorique(Rafraichissable r,String anum) {
NomRetenuAsynchroneDAO nraDAO = new NomRetenuAsynchroneDAO(this);
nraDAO.obtenirNomRetenu(r, anum);
}
 
 
 
public void importerObservations() {
ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this);
ioDAO.importerObservations();
}
 
 
 
public void obtenirArbreMotsCles(Rafraichissable r) {
MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs");
mcoDAO.obtenirListeMotsCles(this);
}
 
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof JSONArray) {
JSONArray donneesArbre = (JSONArray)nouvelleDonnees;
Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre("Projets", "racine_obs", donneesArbre, false);
arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0];
motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1];
// 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
observationMediateur.rafraichirArbreMotsCles(arbreMotsCles);
}
if(nouvelleDonnees instanceof Observation) {
observationMediateur.obtenirNombreObservation();
}
}
 
/**
* 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
*/
@SuppressWarnings("unchecked")
public void rafraichirMotsCles(Object o) {
if (o instanceof HashMap) {
motsCles = (HashMap<String, String>) o;
}
}
/**
* 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) {
Observation o = cacheObservation.get(id);
String motsClesId = o.getMotsCles();
String[] motsClesIdTab = motsClesId.split(",");
r.rafraichir(motsClesIdTab, false);
}
/**
* Met à jour les mots clés associés à une obs et appelle le DAO pour
* synchroniser la base de données
*
* @param ids
* les identifiants des observations selectionnées
* @param motsClesEnCours
* les mots clés à appliquer aux observations
*/
public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
String motsCles = "";
String obsAlier = "";
int nbObs = 0;
for (int i = 0; i < idsObsALier.length; i++) {
if (cacheObservation.containsKey(idsObsALier[i])) {
if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) {
motsCles += ";";
}
motsCles += motsClesEnCours;
nbObs++;
Observation m = cacheObservation.get(idsObsALier[i]);
obsAlier += ","+m.getId();
if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) {
motsCles += ";";
}
m.setMotsCles(m.getMotsCles()+motsCles);
cacheObservation.put(m.getNumeroOrdre(), m);
}
}
while(obsAlier.startsWith(",")) {
obsAlier = obsAlier.replaceFirst(",", "");
}
if(nbObs > 0) {
LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours);
}
}
public void supprimerLiaisonMotCleObservations(
Rafraichissable r, String idObs, String idMC) {
LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this);
lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC);
}
/**
* 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, Rafraichissable r) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
 
if (!id.equals("racine_obs")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
if(!parentUsObj[1].equals("racine_obs")) {
parentId = parentUsObj[1];
}
}
rafraichirArbreMotsCles(arbreMC);
motsCles.put(id, motCle);
 
String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle="
+ motCle + "&id=" + id + "&parent=" + parentId;
MCDao.ajouterBaseDeDonnees(nouveauMotCle, r);
}
 
/**
* 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, Rafraichissable r) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 
String[] usObj = (String[]) n.getUserObject();
String id = usObj[1];
rafraichirArbreMotsCles(arbreMC);
 
MCDao.supprimerBaseDeDonnees(id, r);
 
}
 
/**
* 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, Rafraichissable r) {
 
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
 
if (!id.equals("racine_obs")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
if(!parentUsObj[1].equals("racine_obs")) {
parentId = parentUsObj[1];
}
}
 
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.modifierBaseDeDonnees(motCleModifie, r);
 
}
 
/**
* 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, Rafraichissable r) {
MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs");
 
String[] usObj = (String[]) n.getUserObject();
String motCle = usObj[0];
String id = usObj[1];
String parentId = "";
if (!id.equals("racine_obs")) {
String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
if(!parentUsObj[1].equals("racine_obs")) {
parentId = parentUsObj[1];
}
}
rafraichirArbreMotsCles(arbreMC);
 
String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
+ parentId;
MCDao.deplacerBaseDeDonnees(motCleModifie, r);
}
/**
* 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 String obtenirTexteMotCle(String id) {
String correspondanceId = "";
String motCleTexte = motsCles.get(id);
if(motCleTexte != null) {
correspondanceId = motCleTexte;
}
return correspondanceId;
}
public void rafraichirCacheObservation(ListeObservation li) {
cacheObservation = li ;
}
 
public ListeObservation getCacheObservation() {
return cacheObservation ;
}
public String getIdPourOrdreObs(String ordreObs) {
return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null;
}
 
public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
infocommune.obtenirInfosCommune(r, nomCommune, codePostal);
}
public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) {
InformationCommuneDAO infocommune = new InformationCommuneDAO(r);
infocommune.obtenirCommunePlusProche(r, lng, lat);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/MotsClesUtilitaire.java
New file
0,0 → 1,207
package org.tela_botanica.client.util;
 
import java.util.HashMap;
 
import org.tela_botanica.client.cel2;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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 MotsClesUtilitaire {
//TODO rassembler tout ce qui construit les arbres de mots clés ici
private static String[] caracteresInterdits = {"\\", "/", ","};
public static String obtenirCheminParent(String cheminMotCle) {
String[] tabChemin = cheminMotCle.split("/");
String cheminParent = "/";
if(tabChemin.length >= 1) {
for(int i = 1; i < tabChemin.length - 1; i++) {
cheminParent += tabChemin[i]+"/";
}
}
return cheminParent;
}
 
public static Object[] construireArbre(String NomRacine, String idRacine,
JSONArray arbreJson, boolean afficherCheckbox) {
Tree arbreMotsCles = new Tree() ;
HashMap<String, String> motsCles = new HashMap<String, String>(0);
HashMap<String, String> parentes = new HashMap<String, String>();
final int taillemax = arbreJson.size();
 
// on crée un arbre vide
TreeNode root = new TreeNode();
root.setId(idRacine);
root.setText(NomRacine);
String[] usObjRacine = {NomRacine, idRacine};
root.setUserObject(usObjRacine);
arbreMotsCles.setRootNode(root);
// le mot clé racine possède le chemin racine ("/")
parentes.put("/", idRacine);
 
// pour chacun des élements du tableau
for (int j = 0; j < taillemax; j++) {
// on extrait les élements du tableau
if (arbreJson.get(j).isObject() != null) {
JSONObject noeud = (JSONObject) arbreJson.get(j);
 
String idMotCle = noeud.get("id_mot_cle")
.isString().stringValue();
String motCle = noeud.get("mot_cle").isString()
.stringValue();
// le chemin est mis en minuscule afin de fusionner toutes
// la variantes minuscules majuscule d'un mot clé
// qui peuvent poser problème
String chemin = noeud.get("chemin").isString()
.stringValue().toLowerCase();
String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin);
String parent = parentes.get(cheminParent);
String[] usObj = {motCle, idMotCle};
 
// et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés
// dans l'ordre hierarchique de leur niveau
// ce qui permet de les traiter séquentiellement)
TreeNode node = new TreeNode();
node.setId(idMotCle);
node.setText(motCle);
if(afficherCheckbox) {
node.setChecked(false);
}
 
Node parentNode = arbreMotsCles.getNodeById(parent);
node.setUserObject(usObj);
parentNode.appendChild(node);
parentes.put(chemin, idMotCle);
motsCles.put(idMotCle, motCle);
}
}
Object[] retour = {arbreMotsCles, motsCles};
return retour;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie, boolean afficherCheckbox) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
for (int i = 0; i < ndNodeFils.length; i++) {
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1]);
if(afficherCheckbox) {
child.setChecked(false);
}
child.setUserObject(usObj);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child, afficherCheckbox);
}
}
}
}
public static TreeNode ajouterNoeud(TreeNode parent, boolean afficherCheckbox) {
// on crée un nouveau noeud vide
TreeNode nd = new TreeNode("");
nd.setCls("x-view-treenode-keyword");
if(afficherCheckbox) {
nd.setChecked(true);
}
// on associe un objet au noeud qui contient des infos
String[] usObject = new String[2];
// l'objet contient le nom du noeud
usObject[0] = "";
usObject[1] = "";
nd.setUserObject(usObject);
String cheminTemporaireAjout = parent.getPath()+"/"+nd.getId();
nd.setId(cheminTemporaireAjout);
return nd;
}
public static String getChaineCaracteresInterdits() {
String interdits = "";
for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
interdits += MotsClesUtilitaire.caracteresInterdits[i]+" ";
}
return interdits;
}
public static boolean estUnMotCleAutorise(String motCle) {
boolean valide = !motCle.trim().isEmpty();
for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
if(motCle.indexOf(MotsClesUtilitaire.caracteresInterdits[i]) != -1) {
valide = false;
break;
}
}
return valide;
}
 
public static boolean estUnePositionAutorisee(TreeNode node, Node parent, String text) {
if(parent == null) {
parent = node.getParentNode();
}
text = normaliserChaine(text);
Node[] noeudsFreres = parent.getChildNodes();
boolean ok = true;
for(int i = 0; i <= noeudsFreres.length; i++) {
if(noeudsFreres[i] != null) {
String cheminFrere = normaliserChaine(noeudsFreres[i].getPath());
String cheminNoeud = normaliserChaine(node.getPath());
String texteNoeudfrere = normaliserChaine(((String[])noeudsFreres[i].getUserObject())[0]);
if(!cheminFrere.equals(cheminNoeud) && text.equals(texteNoeudfrere)) {
ok = false;
}
}
}
return ok;
}
public static String normaliserChaine(String chaine) {
return supprimerAccents(chaine).toLowerCase().trim();
}
public static String supprimerAccents(String chaine) {
String s = chaine;
 
s = s.replaceAll("[èéêë]","e");
s = s.replaceAll("[ûùü]","u");
s = s.replaceAll("[ïî]","i");
s = s.replaceAll("[àâ]","a");
s = s.replaceAll("ô","o");
 
s = s.replaceAll("[ÈÉÊË]","E");
s = s.replaceAll("[ÛÙÜ]","U");
s = s.replaceAll("[ÏÎ]","I");
s = s.replaceAll("[ÀÂ]","A");
s = s.replaceAll("Ô","O");
 
return s;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/AutoCompletionRefComboBox.java
New file
0,0 → 1,170
package org.tela_botanica.client.util;
 
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
 
public abstract class AutoCompletionRefComboBox extends ComboBox implements Rafraichissable {
// TODO: faire un enum
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
private ObservationMediateur oMediateur = null;
private TypesReferentiels typeRef = null;
private boolean selectionValeur = false;
private boolean estModifie = false;
final String resultTplRefPerso = "<div class=\"search-item-ref\">{element_referentiel}</div>";
public AutoCompletionRefComboBox(String label, String nom, ObservationMediateur oMediateur, TypesReferentiels typeRef) {
// Accesskey pour debugging
super(label,nom);
this.oMediateur = oMediateur;
this.typeRef = typeRef;
 
setTpl(resultTplRefPerso);
setMode(ComboBox.REMOTE);
setItemSelector("div.search-item-ref");
setTypeAhead(true);
setLoadingText("Recherche...");
setHideTrigger(true);
ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
listenerConfigAutocompletion.setDelay(200);
listenerConfigAutocompletion.setStopPropagation(false);
listenerConfigAutocompletion.setStopEvent(false);
addKeyPressListener(new EventCallback() {
 
@Override
public void execute(EventObject e) {
 
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if (selectionValeur) {
estModifie= true;
selectionValeur=false;
onModificationValeur();
}
else {
onValidationSaisie();
}
break;
default:
estModifie = true;
onModificationValeur();
obtenirReferentiel();
}
}
},listenerConfigAutocompletion);
// Listener completion
addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
setValue(record.getAsString("element_referentiel"));
selectionValeur=true;
collapse();
}
});
}
 
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
ListeReferentielPerso referentielPerso = (ListeReferentielPerso)nouvelleDonnees;
int i = 0;
Object[][] refData = new Object[referentielPerso.size()][1];
for (Iterator<String> it = referentielPerso.keySet().iterator(); it.hasNext();)
{
String ref= referentielPerso.get(it.next());
refData[i][0]= ref;
i++;
}
FieldDef defStation = new StringFieldDef("element_referentiel");
FieldDef[] defTab = {defStation};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(refData);
final ArrayReader reader = new ArrayReader(rd);
Store store=new Store(dataProxy,reader);
setStore(store);
store.load();
}
private void obtenirReferentiel() {
String valeurChamp = getValue();
if(valeurChamp == null) {
valeurChamp = "";
}
oMediateur.obtenirListeReferentielPerso(this, typeRef, valeurChamp);
}
public abstract void onValidationSaisie();
public abstract void onModificationValeur();
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/RequestBuilderWithCredentials.java
New file
0,0 → 1,11
package org.tela_botanica.client.util;
 
import com.google.gwt.http.client.RequestBuilder;
 
public class RequestBuilderWithCredentials extends RequestBuilder {
 
public RequestBuilderWithCredentials(Method httpMethod, String url) {
super(httpMethod, url);
this.setIncludeCredentials(true);
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/ChampSaisieEtendu.java
New file
0,0 → 1,286
package org.tela_botanica.client.util;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
 
import com.google.gwt.core.client.Callback;
import com.google.gwt.user.client.Timer;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.ToolTip;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
 
public class ChampSaisieEtendu extends ComboBox implements Rafraichissable {
// TODO: faire un enum
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
private boolean selectionValeur = false;
private boolean estModifie = false;
private String cle = null;
private String label = null;
private Timer timer = null;
final String resultTplRefPerso = "<div class=\"search-item-ref\">{valeur}</div>";
private List<String> cacheValeurs;
private Record rdSelectionne = null;
private String valeurBrute = "";
private String description = null;
private ToolTip tpDesc = null;
public ChampSaisieEtendu(String label, String cle) {
 
super(label,cle);
 
this.cle =cle;
this.label = label;
setTpl(resultTplRefPerso);
setMode(ComboBox.REMOTE);
setItemSelector("div.search-item-ref");
setTypeAhead(false);
setLoadingText("Recherche...");
setHideTrigger(true);
setValidateOnBlur(false);
ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
listenerConfigAutocompletion.setDelay(200);
listenerConfigAutocompletion.setStopPropagation(false);
listenerConfigAutocompletion.setStopEvent(false);
initStoreVide();
if(Configuration.saisieChampsEtendusActivee()) {
addKeyPressListener(new EventCallback() {
@Override
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if(rdSelectionne != null) {
setValue(rdSelectionne.getAsString("valeur"));
selectionValeur=true;
valeurBrute = rdSelectionne.getAsString("valeur");
}
break;
case KEY_DOWN:
if(getValueAsString().isEmpty() && !isExpanded()) {
obtenirListeValeurs("*");
}
break;
default:
if(timer != null) {
timer.cancel();
}
timer = new Timer() {
@Override
public void run() {
obtenirListeValeurs();
}
};
timer.schedule(300);
valeurBrute = getValueAsString();
setValue(valeurBrute);
}
}
},listenerConfigAutocompletion);
}
addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
rdSelectionne = record;
setRawValue(rdSelectionne.getAsString("valeur"));
}
@Override
public void onBlur(Field field) {
if(rdSelectionne != null && !rdSelectionne.getAsString("valeur").equals(valeurBrute)) {
setRawValue(valeurBrute);
}
}
});
// A activer pour télécharger la description
// si jamais on le décide
addListener(new ComboBoxListenerAdapter() {
@Override
public void onRender(Component component) {
setLargeurChamp();
ChampSaisieEtendu.this.getEl().addListener("mouseover", new EventCallback() {
@Override
public void execute(EventObject e) {
if(description == null) {
telechargerEtAfficherDescriptionDistante();
} else {
afficherDescription(description);
}
}
});
}
});
}
 
private void telechargerEtAfficherDescriptionDistante() {
ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() {
@Override
public void onSuccess(String description) {
ChampSaisieEtendu.this.description = description;
afficherDescription(description);
}
@Override
public void onFailure(String description) {
afficherDescription(description);
}
});
}
private void afficherDescription(String description) {
if(!description.trim().isEmpty()) {
if(tpDesc == null) {
tpDesc = new ToolTip(description);
tpDesc.applyTo(this.getElement());
tpDesc.showAt(ChampSaisieEtendu.this.getEl().getX(), ChampSaisieEtendu.this.getEl().getY());
} else {
tpDesc.show();
}
}
}
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
@SuppressWarnings("unchecked")
ArrayList<String> valeurs = (ArrayList<String>)nouvelleDonnees;
cacheValeurs = valeurs;
 
int i = 0;
Object[][] refData = new Object[valeurs.size()][1];
for (Iterator<String> it = valeurs.iterator(); it.hasNext();)
{
refData[i][0]= it.next();
i++;
}
FieldDef defValeur = new StringFieldDef("valeur");
FieldDef[] defTab = {defValeur};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(refData);
final ArrayReader reader = new ArrayReader(rd);
Store store = new Store(dataProxy,reader);
setStore(store);
store.load();
}
private void obtenirListeValeurs() {
String valeurChamp = getRawValue();
obtenirListeValeurs(valeurChamp);
}
private void obtenirListeValeurs(String valeurChamp) {
if(valeurChamp == null) {
valeurChamp = "";
} else {
valeurChamp += "*";
}
ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
lrceDao.obtenirListeValeursChampEtendu(this, cle, valeurChamp);
}
public void setLargeurChamp() {
// Correction un peu moche pour améliorer l'affichage du champ
String idElementEnfant = Ext.get(("x-form-el-"+cle)).getFirstChild().getId();
Ext.get(idElementEnfant).setWidth("90%", false);
Ext.get(cle).setWidth("100%", false);
}
private void initStoreVide() {
Object[][] refData = new Object[0][1];
FieldDef defValeur = new StringFieldDef("valeur");
FieldDef[] defTab = {defValeur};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(refData);
final ArrayReader reader = new ArrayReader(rd);
Store store = new Store(dataProxy,reader);
setStore(store);
store.load();
}
@Override
public void setValue(String valeur) {
valeurBrute = valeur;
super.setValue(valeur);
}
public String getCle() {
return cle;
}
public String getLabel() {
return label;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/Util.java
New file
0,0 → 1,423
package org.tela_botanica.client.util;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;
 
import org.tela_botanica.client.modeles.objets.ChampEtendu;
import org.tela_botanica.client.modeles.objets.Observation;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONString;
 
public class Util {
 
public Util() {
}
public static String getValeurJsonOuVide(JSONObject jo, String index) {
return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";
}
public static Map<String, ChampEtendu> getMapValeursOuVide(JSONObject jo, String index) {
Map<String, ChampEtendu> mapValeurs = new HashMap<String, ChampEtendu>();
if(jo.get(index) != null && jo.get(index).isArray() != null) {
JSONArray tabJo = jo.get(index).isArray();
for (int i = 0; i < tabJo.size(); i++) {
JSONObject champJson = tabJo.get(i).isObject();
String cle = champJson.get("cle").isString().stringValue();
String label = cle;
String valeur = champJson.get("valeur").isString().stringValue();
ChampEtendu champ = new ChampEtendu(cle, label, valeur);
mapValeurs.put(cle, champ);
}
 
}
return mapValeurs;
}
public static String convertirChampsEtendusEnChaineRequete(Map<String, ChampEtendu> map) {
String json = "";
if (map != null && !map.isEmpty()) {
JSONArray jsonArr = new JSONArray();
int i = 0;
for (Map.Entry<String, ChampEtendu> entry: map.entrySet()) {
jsonArr.set(i, convertirChampEtenduEnJson(entry.getValue()));
i++;
}
json = jsonArr.toString();
}
return json;
}
public static JSONObject convertirChampEtenduEnJson(ChampEtendu champEtendu) {
JSONObject jsonObj = new JSONObject();
jsonObj.put("cle", new JSONString(champEtendu.getCle()));
jsonObj.put("label", new JSONString(champEtendu.getLabel()));
jsonObj.put("valeur", new JSONString(champEtendu.getValeur()));
return jsonObj;
}
public static boolean jsonNonNull(JSONObject jo, String index) {
return (jo != null &&
jo.get(index) != null &&
jo.get(index).isNull() == null
);
}
public static String formaterLieu(Observation obs, String modeleLieu) {
String lieuModele = modeleLieu;
String commune = obs.getLocalite();
String lieuDit = obs.getLieudit();
String station = obs.getStation();
String lieuCommuneFormate = "";
String lieuDitFormate = "";
String stationFormatee = "";
if(commune != null && !commune.contains("000null") && !commune.trim().equals("")) {
String idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/");
if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) {
 
idLoc = idLoc.replaceAll("%","");
idLoc = idLoc.replaceAll("\"","");
idLoc = idLoc.replace('\\',' ');
idLoc = idLoc.trim();
if(idLoc.length() > 2) {
idLoc = idLoc.substring(0,2);
}
lieuCommuneFormate += idLoc+" - ";
}
lieuCommuneFormate += commune;
lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE", lieuCommuneFormate);
} else {
lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE,", lieuCommuneFormate);
}
if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) {
lieuDitFormate += lieuDit;
lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate);
} else {
lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate);
}
if(station != null && !station.contains("000null") && !station.trim().equals("")) {
stationFormatee += station;
lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
} else {
lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
}
lieuModele = lieuModele.trim();
lieuModele = lieuModele.replaceAll(",$","");
lieuModele = lieuModele.replaceAll(",^$",", ");
return lieuModele;
}
public static String obtenirDepartementAPartirChaineCommune(String departement, String commune) {
String dep = "";
if(departement == null) {
departement = "";
}
if(departement.equals("000null") || departement.equals("")) {
String[] depCom = commune.split(" ");
if(depCom.length > 1) {
dep = depCom[1].replace('(', ' ');
} else {
dep = "";
}
} else {
dep = departement;
}
dep = dep.replace(')', ' ');
dep = dep.trim();
dep = dep.replace('\\',' ');
dep = dep.trim();
try
{
int nDep = Integer.parseInt(dep);
if(nDep > 0 && nDep < 110) {
departement = dep ;
}
if(departement.length() == 4) {
departement = "0"+departement;
}
departement = departement.substring(0,2);
}
catch(NumberFormatException e)
{
departement = "" ;
}
return departement;
}
public static String supprimerNumDepartementChaineLocalite(String chaineLocaliteComplete) {
return chaineLocaliteComplete.replaceAll(" \\([0-9]*\\)", "");
}
public static String convertirChaineZoneGeoVersDepartement(String chaineZoneGeo) {
return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("") && chaineZoneGeo.replaceAll("INSEE-C:", "").length() >= 2) ?
chaineZoneGeo.replaceAll("INSEE-C:", "").substring(0, 2) :
chaineZoneGeo;
}
public static String convertirChaineZoneGeoVersCodeInsee(String chaineZoneGeo) {
return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("")) ? chaineZoneGeo.replaceAll("INSEE-C:", ""): chaineZoneGeo;
}
/***
* Fusionne les éléments d'un tableau en une chaîne
* @param delim : la chaîne de séparation
* @param args : la tableau
* @return la chaîne fusionnée
*/
public static String implode(String delim, String[] args){
StringBuffer sb = new StringBuffer();
int lgArgs = args.length;
for(int i = 0; i < lgArgs; i++){
if (i > 0) {
sb.append(delim);
}
sb.append(args[i]);
}
return sb.toString();
}
public static boolean filtreValide(String[] filtre) {
return (filtre.length == 2 &&
filtre[0] != null &&
!filtre[0].equals("") &&
filtre[1] != null &&
!filtre[1].equals(""));
}
public static String renvoyerMois(int numMois) {
switch (numMois) {
case 1:
return "janvier" ;
case 2:
return "fevrier" ;
case 3:
return "mars" ;
case 4:
return "avril" ;
case 5:
return "mai" ;
case 6:
return "juin" ;
case 7:
return "juillet" ;
case 8:
return "août" ;
case 9:
return "septembre" ;
case 10:
return "octobre" ;
case 11:
return "novembre" ;
case 12:
return "décembre" ;
default:
return "Inconnu" ;
}
}
public static String remplacerSautsDeligneMalEncodes(String chaineAvecSautsDeLignesMalEncodes) {
String chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesMalEncodes.replace('\\','%');
chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replaceAll("%n","%");
chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replace('%','\n');
return chaineAvecSautsDeLignesBienEncodes;
}
public static boolean verifierDateFormatCel(String dateAVerifier) {
String dateRemplacee = remplacerSeparateursDateFormatCel(dateAVerifier);
String[] tabDate = dateRemplacee.split("/");
boolean retour = false;
if(tabDate.length == 3) {
//TODO: faire un parsing de date qui fonctionne mieux car
// on peut saisir un 31 novembre par exemple
// mais l'api date de java est mal gérée par gwt
try {
int jour = Integer.parseInt(tabDate[0]);
int mois = Integer.parseInt(tabDate[1]);
int annee = Integer.parseInt(tabDate[2]);
if(jour <= 31 && mois <= 12 && tabDate[2].length() == 4) {
retour = true;
}
} catch (Exception e) {
 
}
}
return retour;
}
public static String remplacerSeparateursDateFormatCel(String date) {
String dateRemplacee = date.replaceAll("-", "/");
return dateRemplacee;
}
public static boolean estZero(String s) {
boolean estZero = false;
try {
Double dou = Double.parseDouble(s);
estZero = (dou == 0);
} catch(NumberFormatException e) {
 
}
return estZero;
}
public static String formaterNombre(String s) {
s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");
return s;
}
 
// Prend un nombre décimal avec le spéparateur spécifié et le tronque à n décimales
public static String tronquerNombrePourAffichage(String nombre, int decimales, char separateur) {
String retour = nombre;
int posSep = nombre.indexOf(separateur);
if (posSep >= 0) {
int taille = posSep + decimales + 1;
if (nombre.length() < taille) {
taille = nombre.length();
}
retour = nombre.substring(0, taille);
}
return retour;
}
 
public static String tronquerNombrePourAffichage(String nombre, int decimales) {
return tronquerNombrePourAffichage(nombre, decimales, '.');
}
// Adapté de http://www.programcreek.com/2011/03/java-method-for-spliting-a-camelcase-string/
public static String formaterCleChampsEtenduPourAffichage(String s) {
char[] cArray = s.toCharArray();
Vector<Integer> al = new Vector<Integer>();
al.add(0);
// get all upper case letter index positions
for (int i = 1; i < cArray.length; i++) {
char c = cArray[i];
//add more interested index beyond upper case letter
if (c >= 65 && c <= 90) {
al.add(i);
}
}
Vector<String> strl = new Vector<String>();
// this handles the all lower letter case
if (al.size() == 1) {
strl.add(s);
return depilerChaineListee(strl, " ");
}
int prev = 0;
int curr = 0;
int begin = 0;
for (int k = 1; k < al.size(); k++) {
curr = al.get(k);
if(curr == s.length() - 1){
}
if (curr == prev + 1 && curr != s.length() - 1) {
prev = curr;
} else if(curr == prev + 1 && curr == s.length() - 1){
strl.add(s.substring(begin, curr+1));
}else {
strl.add(s.substring(prev, curr));
prev = curr;
begin = curr;
if (k == al.size() - 1) {
strl.add(s.substring(curr, s.length()));
}
}
}
return depilerChaineListee(strl, " ");
}
private static String depilerChaineListee(Vector<String> strl, String separateur) {
String s = "";
for(int i = 0; i < strl.size(); i++) {
s += strl.get(i);
if(i != strl.size() - 1) {
s += separateur;
}
}
return s;
}
public static Map<String, ChampEtendu> trierListeChampsEtendus(Map<String, ChampEtendu> listeChampsEtendus) {
List<String> tmp = new ArrayList<String>(listeChampsEtendus.keySet());
Collections.sort(tmp, new Comparator<String>() {
@Override
public int compare(String arg0, String arg1) {
return arg0.compareTo(arg1);
}
});
return listeChampsEtendus;
}
/**
* Solution issue de stackoverflow :
* http://stackoverflow.com/questions/1143951/what-is-the-simplest-way-to-convert-a-java-string-from-all-caps-words-separated
*/
public static String convertirEnChaMot(String s) {
s = s.replaceAll("_", " ");
s = s.replaceAll("-", " ");
String[] parties = s.split(" ");
String chaineChaMot = "";
for (String partie : parties){
chaineChaMot = chaineChaMot + convertirMotEnChaMot(partie);
}
return chaineChaMot;
}
 
protected static String convertirMotEnChaMot(String s) {
return s.substring(0, 1).toUpperCase() +
s.substring(1).toLowerCase();
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/util/FormulaireSaisieChampEtendu.java
New file
0,0 → 1,462
package org.tela_botanica.client.util;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO;
import org.tela_botanica.client.modeles.objets.ListeChampsEtendus;
import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus;
 
import com.google.gwt.core.client.Callback;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.layout.FormLayout;
 
@SuppressWarnings("unchecked")
public abstract class FormulaireSaisieChampEtendu extends FormPanel implements Rafraichissable {
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
final ComboBox nChamp;
final String resultTplRefPerso = "<div class=\"search-item-ref\">{label_fmt}</div>";
Button ajouterChampsEtenduEtFermer;
Button ajouterChampsEtendu;
Button annulerAjouterChampEtendu;
String idChamp = null;
Panel conteneurGroupesChampsEtendus;
final ComboBox groupesChampsEtendus;
HTML indicationSaisieGroupe;
private static ListeGroupesChampsEtendus cacheGroupes;
private Timer timer = null;
private static Map<String, String> cacheClesValeur;
private HTML descriptionChamp = null;
private Record rdSelectionne = null;
private Record groupeSelectionne = null;
private String valeurBrute = "";
public FormulaireSaisieChampEtendu() {
super();
setPaddings(3);
setBodyBorder(false);
indicationSaisieGroupe = new HTML("Vous pouvez ajouter plusieurs champs à la fois correspondant à un groupe "+
"par exemple les champs des projet 'sauvages de ma rue' ou 'florilèges', etc... <br />"+
"De nouveaux groupes seront ajoutés régulièrement en fonction des champs les plus utilisés");
indicationSaisieGroupe.addStyleName("aideCreerChampEtendu");
groupesChampsEtendus = new ComboBox();
groupesChampsEtendus.setWidth("350px");
groupesChampsEtendus.setLabel("Ajouter un groupe de champs");
groupesChampsEtendus.setDisplayField("label") ;
groupesChampsEtendus.setValueField("cle");
groupesChampsEtendus.setEditable(false);
groupesChampsEtendus.setHideTrigger(false);
groupesChampsEtendus.setForceSelection(true);
groupesChampsEtendus.setCls("champ-separation");
groupesChampsEtendus.setValue("");
conteneurGroupesChampsEtendus = new Panel();
conteneurGroupesChampsEtendus.setBorder(false);
conteneurGroupesChampsEtendus.setPaddings(0);
conteneurGroupesChampsEtendus.setMargins(0);
conteneurGroupesChampsEtendus.setLayout(new FormLayout());
conteneurGroupesChampsEtendus.setWidth("100%");
add(conteneurGroupesChampsEtendus);
if(cacheGroupes == null) {
ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null);
lrceDao.obtenirGroupesChampsEtendus(this);
} else {
this.rafraichir(cacheGroupes, false);
}
HTML indicationSaisie = new HTML("Saisissez un nom de champ ou choisisez un nom proposé par l'autocomplétion "+
"Si vous choissisez un nom de champ existant vous pourrez profiter d'une autocomplétion "+
"sur les valeurs déjà saisies pour ce champ par les autres utilisateurs.<br /> "+
"Les champs de la forme 'label (clé)' sont des champs 'standards' ayant un rôle et une description " +
"bien définie");
indicationSaisie.addStyleName("aideCreerChampEtendu");
add(indicationSaisie);
HorizontalPanel hp = new HorizontalPanel();
hp.setBorderWidth(0);
nChamp = new ComboBox("Nom du champ", "nom_champ_etendu");
nChamp.setWidth("350px");
nChamp.setTpl(resultTplRefPerso);
nChamp.setMode(ComboBox.REMOTE);
nChamp.setItemSelector("div.search-item-ref");
nChamp.setTypeAhead(false);
nChamp.setLoadingText("Recherche...");
nChamp.setHideTrigger(true);
nChamp.setValidateOnBlur(false);
Store store = initStoreChampsEtendusVide();
store.load();
nChamp.setStore(store);
add(nChamp);
descriptionChamp = new HTML();
descriptionChamp.addStyleName("aideWikiChampEtendu");
add(descriptionChamp);
ajouterChampsEtenduEtFermer = new Button("Ajouter et fermer");
ajouterChampsEtenduEtFermer.setTooltip("Ajouter un champ étendu ou un groupe de champs et fermer la fenêtre");
ajouterChampsEtendu = new Button("Ajouter");
ajouterChampsEtendu.setTooltip("Ajouter un champ étendu ou un groupe de champ");
annulerAjouterChampEtendu = new Button("Annuler");
annulerAjouterChampEtendu.setTooltip("Fermer la fenêtre sans ajouter de champ");
hp.add(ajouterChampsEtenduEtFermer);
hp.add(ajouterChampsEtendu);
hp.add(annulerAjouterChampEtendu);
add(hp);
ajouterListeners();
}
 
private void ajouterListeners() {
ListenerConfig listenerConfigAutocompletion=new ListenerConfig();
listenerConfigAutocompletion.setDelay(200);
listenerConfigAutocompletion.setStopPropagation(false);
listenerConfigAutocompletion.setStopEvent(true);
nChamp.addKeyPressListener(new EventCallback() {
 
@Override
public void execute(EventObject e) {
 
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_END:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if(rdSelectionne != null) {
nChamp.setValue(rdSelectionne.getAsString("label"));
valeurBrute = rdSelectionne.getAsString("cle");
}
break;
case KEY_DOWN:
if(nChamp.getValueAsString().isEmpty() && !nChamp.isExpanded()) {
obtenirListeValeurs("*");
}
break;
case KEY_ESCAPE:
surAnnulation();
break;
default:
if(timer != null) {
timer.cancel();
}
timer = new Timer() {
@Override
public void run() {
obtenirListeValeurs();
}
};
timer.schedule(300);
valeurBrute = nChamp.getRawValue();
nChamp.setRawValue(valeurBrute);
}
}
},listenerConfigAutocompletion);
nChamp.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
rdSelectionne = record;
telechargerEtAfficherDescriptionChamps(rdSelectionne.getAsString("cle"));
nChamp.setRawValue(rdSelectionne.getAsString("label"));
valeurBrute = rdSelectionne.getAsString("cle");
}
 
@Override
public void onBlur(Field field) {
if(rdSelectionne != null && !rdSelectionne.getAsString("cle").equals(valeurBrute)) {
nChamp.setRawValue(valeurBrute);
}
telechargerEtAfficherDescriptionChamps(valeurBrute);
}
});
groupesChampsEtendus.addListener(new ComboBoxListenerAdapter() {
@Override
public void onSelect(ComboBox comboBox, Record record, int index) {
groupeSelectionne = record;
}
});
ajouterChampsEtenduEtFermer.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(doitAjouterGroupe()) {
surValidationMultiple(renvoyerListeChampsEtendus(groupeSelectionne.getAsString("cle")));
} else {
if(champEtenduEstValide()) {
surValidation(validerEtRenvoyerChampEtendu());
} else {
Window.alert("Le nom du champ étendu ne peut pas être vide");
}
}
}
});
ajouterChampsEtendu.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(champEtenduEstValide()) {
surAjout(validerEtRenvoyerChampEtendu());
raz();
} else {
Window.alert("Le nom du champ étendu ne peut pas être vide");
}
}
});
annulerAjouterChampEtendu.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
surAnnulation();
}
});
}
private void raz() {
timer = null;
idChamp = null;
nChamp.clearValue();
nChamp.focus();
}
private ChampSaisieEtendu validerEtRenvoyerChampEtendu() {
String valeurChamp = nChamp.getRawValue();
// Valeur contient soit la clé, soit le label s'il existe
// valeur brute contient toujours la clé
// TODO: utiliser les champs de google et pas ceux de GWT-EXT qui puent du cul
ChampSaisieEtendu retour = new ChampSaisieEtendu(valeurChamp, valeurBrute);
retour.setId(valeurBrute);
return retour;
}
private List<ChampSaisieEtendu> renvoyerListeChampsEtendus(String groupe) {
List<ChampSaisieEtendu> champsDuGroupe = new ArrayList<ChampSaisieEtendu>();
HashMap<String, String> listeChampsEtendus = cacheGroupes.get(groupe);
for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator.hasNext();) {
String cle = iterator.next();
String label = listeChampsEtendus.get(cle);
ChampSaisieEtendu champ = new ChampSaisieEtendu(label, cle);
champsDuGroupe.add(champ);
}
 
return champsDuGroupe;
}
private boolean doitAjouterGroupe() {
return groupeSelectionne != null && !groupeSelectionne.getAsString("cle").equals("");
}
private boolean champEtenduEstValide() {
String valeurChamp = nChamp.getRawValue();
return (valeurChamp != null && !valeurChamp.isEmpty());
}
private boolean estUnChampSelectionne(String valeur) {
return cacheClesValeur.containsValue(valeur);
}
private void obtenirListeValeurs() {
obtenirListeValeurs(nChamp.getRawValue());
}
private void obtenirListeValeurs(String valeur) {
ListeReferentielChampsEtendusDAO lrce = new ListeReferentielChampsEtendusDAO(null);
lrce.obtenirListeNomsChampsEtendus(this, valeur+"*");
}
public abstract void surAjout(ChampSaisieEtendu champ);
public abstract void surAjoutMultiple(List<ChampSaisieEtendu> champs);
public abstract void surValidation(ChampSaisieEtendu champ);
public abstract void surValidationMultiple(List<ChampSaisieEtendu> champs);
public abstract void surAnnulation();
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof ListeChampsEtendus) {
int i = 0;
ListeChampsEtendus clesLabels = (ListeChampsEtendus)nouvelleDonnees;
cacheClesValeur = clesLabels;
Object[][] refData = new Object[clesLabels.keySet().size()][3];
for (Iterator<String> it = clesLabels.keySet().iterator(); it.hasNext();)
{
String cle = it.next();
String label = clesLabels.get(cle);
refData[i][0]= cle;
refData[i][1]= label;
if(cle.equals(label.toLowerCase())) {
refData[i][2]= label;
} else {
refData[i][2]= label+" ("+cle+")";
}
 
i++;
}
FieldDef defCle = new StringFieldDef("cle");
FieldDef defLabel = new StringFieldDef("label");
FieldDef defLabelFmt = new StringFieldDef("label_fmt");
FieldDef[] defTab = {defCle, defLabel, defLabelFmt};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(refData);
final ArrayReader reader = new ArrayReader(rd);
Store store=new Store(dataProxy,reader);
nChamp.setStore(store);
store.load();
}
if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) {
cacheGroupes = (ListeGroupesChampsEtendus)nouvelleDonnees;
groupesChampsEtendus.setStore(getGroupesChampsEtendusStore(cacheGroupes));
if(cacheGroupes.size() > 0) {
conteneurGroupesChampsEtendus.add(indicationSaisieGroupe);
conteneurGroupesChampsEtendus.add(groupesChampsEtendus);
doLayout();
}
}
}
private void telechargerEtAfficherDescriptionChamps(final String cle) {
ListeReferentielChampsEtendusDAO.telechargerDescriptionWikini(cle, new Callback<String, String>() {
@Override
public void onSuccess(String description) {
afficherDescriptionEtLienWikiChampEtendu(cle, description);
}
@Override
public void onFailure(String reason) {
// rien
}
});
}
private void afficherDescriptionEtLienWikiChampEtendu(final String cle, String description) {
if(description.trim().isEmpty()) {
String urlDesc = ListeReferentielChampsEtendusDAO.obtenirUrlEditionDescriptionWiki(cle);
descriptionChamp.setHTML("<span> Aucune description n'existe pour ce champ.<br />" +
"Vous pouvez la remplir sur cette page :" +
"<a id=\"lien_description_wiki_ce_"+cle+"\" href="+urlDesc+" target=\"_blank\">"+cle+"</span></span>");
Ext.get("lien_description_wiki_ce_"+cle).addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
ListeReferentielChampsEtendusDAO.creerPageWikini(cle);
}
});
} else {
descriptionChamp.setHTML("<span class=\"descriptionChampEtenduTitre\">Description :</span> "+description);
}
}
private Store getGroupesChampsEtendusStore(ListeGroupesChampsEtendus listeGroupesChampsEtendus) {
int i = 1;
Object[][] valeurs = new Object[listeGroupesChampsEtendus.size()+1][2];
valeurs[0][0] = "...";
valeurs[0][1] = "";
if(listeGroupesChampsEtendus.size() > 0) {
for (Iterator<String> it = listeGroupesChampsEtendus.keySet().iterator(); it.hasNext();)
{
String cle = it.next();
valeurs[i][0]= cle;
valeurs[i][1]= cle;
i++;
}
}
SimpleStore store = new SimpleStore(new String[] {"label","cle"},valeurs);
store.load();
return store;
}
private Store initStoreChampsEtendusVide() {
Object[][] refData = new Object[0][1];
FieldDef defLabel = new StringFieldDef("label");
FieldDef defCle = new StringFieldDef("cle");
FieldDef[] defTab = {defLabel, defCle};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(refData);
final ArrayReader reader = new ArrayReader(rd);
Store store = new Store(dataProxy,reader);
return store;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/CarnetEnLigneMediateur.java
New file
0,0 → 1,498
package org.tela_botanica.client;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.vues.EtatConnexionVue;
import org.tela_botanica.client.vues.FenetreLicenceVue;
import org.tela_botanica.client.vues.FormulaireDeConnexionVue;
import org.tela_botanica.client.vues.ListeUtilisateurAdminVue;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.Tool;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.TabPanelListenerAdapter;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
 
/**
* Mediateur gérant les interactions entre vues et les echanges de données
* C'est un singleton.
* @author david delon
*
*/
 
public class CarnetEnLigneMediateur implements Rafraichissable {
/**
* booleen qui verifie l'unicite de l'instance
*/
private static boolean estInstancie = false ;
 
/**
* pointeur vers le médiateur lui même (pour le pattern singleton)
*/
private static CarnetEnLigneMediateur thisMediateur = null ;
/**
* modele de données
*/
private CarnetEnLigneModele carnetEnLigneModele=null;
 
/**
* panneau principal de l'application "Carnet en ligne"
*/
 
private Panel panneauPrincipalCarnetEnLigne= null ;
/**
* panneau a onglet pour les observation et les images
*/
private com.gwtext.client.widgets.TabPanel ongletsObservationsImages=null;
/**
* Indicateur d'etat de la connexion utilisateur
*/
private EtatConnexionVue etatConnexionVue=null;
/**
* Texte d'invite connexion
*/
private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica";
 
/**
* Boolean indiquant un essai de connexion
*/
private boolean tentativeConnection=false;
/**
* Booleen indique que la licence a été acceptée
*/
private boolean licenceUtilisateurAcceptee = false;
 
/**
* Formulaire de connexion (lazy instantiation)
*
*/
private FormulaireDeConnexionVue formulaireDeConnexionVue=null;
/**
*
*/
private Panel bandeau = null ;
private Panel panneauAdmin = null ;
Tool cacherPanneau = null ;
private FenetreLicenceVue fenetreAcceptationLicence = null;
/**
* Mediateur Gestion des images
*/
private ImageMediateur imageMediateur=null;
/**
* Mediateur Gestion des observations
*/
private ObservationMediateur observationMediateur=null;
/**
* Utilisateur en cours
*/
 
private Utilisateur utilisateur=null;
 
public static CarnetEnLigneMediateur Instance()
{
if(!estInstancie || thisMediateur==null)
{
estInstancie = true ;
thisMediateur = new CarnetEnLigneMediateur() ;
}
return thisMediateur ;
}
/**
* constructeur privé (on accède a la classe par la méthode getInstance
*/
private CarnetEnLigneMediateur() {
panneauPrincipalCarnetEnLigne = new Panel("Carnet en ligne");
// Disposition
panneauPrincipalCarnetEnLigne.setLayout(new RowLayout());
 
// Pourrait etre fait plus loin ...
carnetEnLigneModele=CarnetEnLigneModele.Instance();
bandeau = new Panel();
bandeau.setId("x-up-bandeau") ;
etatConnexionVue=new EtatConnexionVue(this);
etatConnexionVue.setLayout(new FitLayout()) ;
// Le panneau à onglet qui contient les 2 applications Observation et Images
ongletsObservationsImages = new TabPanel();
panneauPrincipalCarnetEnLigne.add(etatConnexionVue,new RowLayoutData(16));
panneauAdmin = new Panel();
panneauAdmin.setId("panneau_admin");
panneauPrincipalCarnetEnLigne.add(panneauAdmin, new RowLayoutData(16));
panneauAdmin.setBorder(false);
panneauAdmin.hide();
panneauPrincipalCarnetEnLigne.add(ongletsObservationsImages,new RowLayoutData());
//panneauPrincipalCarnetEnLigne.addTool(cacherPanneau) ;
// On ajoute les applications
observationMediateur = ObservationMediateur.Instance(this);
imageMediateur= ImageMediateur.Instance(this);
if(!GWT.isScript()) {
//temp dd viewport desactive ajout de cette ligne
getPanneauPrincipalCarnetEnLigne().setHeight(Window.getClientHeight()) ;
}
panneauPrincipalCarnetEnLigne.addListener(new ContainerListenerAdapter() {
 
@Override
public void onResize(BoxComponent component, int adjWidth,
int adjHeight, int rawWidth, int rawHeight) {
CarnetEnLigneMediateur.fireResize();
observationMediateur.redimensionnerPanneaux(adjHeight, adjWidth);
}
});
ongletsObservationsImages.addListener(new TabPanelListenerAdapter() {
@Override
public void onTabChange(TabPanel source, Panel tab) {
if(tab.equals(imageMediateur.getPanneauPrincipalImage())) {
Timer t = new Timer() {
@Override
public void run() {
imageMediateur.obtenirNombreMiniListeObservations();
imageMediateur.rafraichirToutesVues();
}
};
t.schedule(150);
}
}
});
// on ajoute les panneaux principaux des applications au panneau à onglets
ongletsObservationsImages.add(observationMediateur.getPanneauPrincipalObservation());
ongletsObservationsImages.add(imageMediateur.getPanneauPrincipalImage());
}
public void getEtatUtilisateur() {
carnetEnLigneModele.getEtatUtilisateur(this);
}
 
 
// Methode publiques
/**
* Recherche Identifiant utilisateur en cours et etat de connection
* @return Utilisateur
*/
public Utilisateur getUtilisateur() {
return utilisateur;
}
 
/**
* Deconnecte l'utilisateur passe en parametre
*/
public void deconnecterUtilisateur() {
licenceUtilisateurAcceptee = false;
// TODO: vider proprement toutes les vues (méthode à voir)
carnetEnLigneModele.deconnecterUtilisateur(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
observationMediateur.deconnecterUtilisateur() ;
imageMediateur.deconnecterUtilisateur();
panneauAdmin.setVisible(false);
}
 
public void connecterUtilisateur(String login, String password) {
tentativeConnection=true;
carnetEnLigneModele.connecterUtilisateur(this, login, password);
}
 
 
/**
* Affichage etat de la connexion
*/
private void afficheEtatConnexion() {
if (!utilisateur.isIdentifie()) {
etatConnexionVue.setEtat("",false);
}
else {
if(utilisateur.isAdmin()) {
afficherLienAdmin();
panneauAdmin.setVisible(true);
} else {
cacherLienAdmin();
}
etatConnexionVue.setEtat(Utilisateur.getInstance().getLoginUtilisateurConsulte(),true);
}
}
private void afficherFenetreAcceptationLicence() {
fenetreAcceptationLicence = new FenetreLicenceVue(this);
// On le positionne à peu près au milieu de l'écran
int left = (Window.getClientWidth() - 512) / 2;
int top = (Window.getClientHeight() - 256) / 5;
fenetreAcceptationLicence.setPosition(left, top);
fenetreAcceptationLicence.setHeight(350);
fenetreAcceptationLicence.setWidth(550);
fenetreAcceptationLicence.setModal(true);
fenetreAcceptationLicence.show();
}
 
/**
*
* Affichage boite de connexion
*
*/
public void afficherDialogueConnexion() {
if (formulaireDeConnexionVue==null) {
formulaireDeConnexionVue= new FormulaireDeConnexionVue(this);
}
// On le positionne à peu près au milieu de l'écran
int left = (Window.getClientWidth() - 512) / 2;
int top = (Window.getClientHeight() - 256) / 2;
formulaireDeConnexionVue.setPopupPosition(left, top);
formulaireDeConnexionVue.show();
}
 
public Panel getPanneauPrincipalCarnetEnLigne() {
return panneauPrincipalCarnetEnLigne;
}
 
@Override
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
 
if (nouvelleDonnees instanceof Utilisateur) {
utilisateur = (Utilisateur) nouvelleDonnees;
if ((tentativeConnection) && !utilisateur.isIdentifie()) {
panneauAdmin.setVisible(false);
formulaireDeConnexionVue.afficherMessageAlerte();
}
else {
if ((tentativeConnection) && utilisateur.isIdentifie()) {
afficherLienAdmin();
formulaireDeConnexionVue.cacher();
}
}
if(utilisateur.isIdentifie() && !utilisateur.getLicenceAcceptee()) {
afficherFenetreAcceptationLicence();
} else {
if(tentativeConnection && utilisateur.isIdentifie() && observationMediateur.listeAvoirObservations() && !utilisateur.isAdmin()) {
if(Window.confirm("Voulez vous importer vos observations déjà saisies dans votre compte une fois connecté ?")) {
observationMediateur.setImporterObservationsAnonymes(true);
}
}
afficheEtatConnexion();
// On lance l'affichage des observations
observationMediateur.connecterUtilisateur();
imageMediateur.connecterUtilisateur();
}
}
if(nouvelleDonnees instanceof String) {
String evenement = (String)nouvelleDonnees;
if(evenement.equals("licence_acceptee")) {
licenceUtilisateurAcceptee = true;
accepterLicenceUtilisateur();
} else {
if(utilisateur.isIdentifie()) {
deconnecterUtilisateur();
return;
}
}
if(observationMediateur.listeAvoirObservations() && !utilisateur.isAdmin()) {
if(Window.confirm("Voulez vous importer vos observations déjà saisies dans votre compte une fois connecté ?")) {
observationMediateur.setImporterObservationsAnonymes(true);
}
}
afficheEtatConnexion();
observationMediateur.connecterUtilisateur();
imageMediateur.connecterUtilisateur();
fenetreAcceptationLicence.close();
}
}
private void accepterLicenceUtilisateur() {
utilisateur.setLicenceAcceptee(true);
carnetEnLigneModele.accepterLicenceUtilisateur(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte());
}
 
public void afficherListeUtilisateurs() {
ListeUtilisateurAdminVue listeUtilisateur = new ListeUtilisateurAdminVue(this) ;
listeUtilisateur.show(Ext.get("LienChangerUtilisateur").getDOM());
listeUtilisateur.focusChampUtilisateur();
}
public void afficherLienAdmin() {
 
String labelAdmin = "<div id=\"lienAdmin\">Vous consultez les données de "+Utilisateur.getInstance().getLoginUtilisateurConsulte()+" <a id=\"LienChangerUtilisateur\" href=\"#\">Changer d'utilisateur</a></div>" ;
panneauAdmin.setHtml(labelAdmin);
ExtElement lienChangerUt = Ext.get("LienChangerUtilisateur");
if(lienChangerUt != null)
{
lienChangerUt.removeAllListeners();
lienChangerUt.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
afficherListeUtilisateurs();
}
});
}
else
{
panneauAdmin.addListener(new ContainerListenerAdapter()
{
@Override
public void onAfterLayout(Container c)
{
ExtElement lienChangerUt = Ext.get("LienChangerUtilisateur");
lienChangerUt.removeAllListeners();
lienChangerUt.addListener("click", new EventCallback() {
 
@Override
public void execute(EventObject e) {
afficherListeUtilisateurs();
}
});
}
});
}
}
public void cacherLienAdmin() {
panneauAdmin.hide();
}
public void changerIdentite(String idNouvelleIdentite, String loginNouvelleIdentite) {
Utilisateur.getInstance().setUtilisateurConsulte(idNouvelleIdentite, loginNouvelleIdentite);
afficherLienAdmin();
observationMediateur.connecterUtilisateur();
imageMediateur.connecterUtilisateur();
}
 
public void obtenirListeUtilisateurs(String rech, Rafraichissable r) {
carnetEnLigneModele.obtenirListeUtilisateur(r,rech,Utilisateur.getInstance().getIdentifiantUtilisateurConnecte());
}
 
public void donneesImagesVersObs(Object o) {
observationMediateur.donneesExterieures(o);
}
public void donneesObsVersImages(Object o) {
imageMediateur.donneesExterieures(o);
}
public void obtenirListeObservations(Rafraichissable r) {
observationMediateur.obtenirCacheObservation(r) ;
}
 
 
public static native void fireResize() /*-{
$wnd.Ext.EventManager.fireResize();
}-*/;
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/i18n/I18n.java
New file
0,0 → 1,19
package org.tela_botanica.client.i18n;
 
import com.google.gwt.core.client.GWT;
 
public class I18n {
public I18n() {
}
 
public static VocabulaireMetadonnees getVocabulaireMetadonnees() {
return (VocabulaireMetadonnees) GWT.create(VocabulaireMetadonnees.class);
}
 
public static Messages getMessages() {
return (Messages) GWT.create(Messages.class);
}
 
}
/branches/v2.8-houe/src/org/tela_botanica/client/i18n/VocabulaireMetadonnees.java
New file
0,0 → 1,23
package org.tela_botanica.client.i18n;
 
import com.google.gwt.i18n.client.Dictionary;
 
/**
* Interface to represent the constants contained in resource bundle:
* '/home/aurelien/web/cel_GWT2/src/org/tela_botanica/client/i18n/VocabulaireMetadonnees.properties'.
*/
public class VocabulaireMetadonnees {
private static Dictionary traductionMetadonnees = Dictionary.getDictionary("traductionMetadonnees");
public static String getTraduction(String terme) {
String traduction = null;
terme = terme.toLowerCase();
terme = terme.replaceAll("-", "");
terme = terme.replaceAll(" ", "");
if(traductionMetadonnees.keySet().contains(terme)) {
traduction = traductionMetadonnees.get(terme);
}
return traduction != null ? traduction : terme;
}
}
/branches/v2.8-houe/src/org/tela_botanica/client/i18n/Messages.java
New file
0,0 → 1,9
package org.tela_botanica.client.i18n;
 
/**
* Interface to represent the constants contained in resource bundle:
* '/home/aurelien/web/cel_GWT2/src/org/tela_botanica/client/i18n/Messages.properties'.
*/
public interface Messages extends com.google.gwt.i18n.client.Constants {
}
/branches/v2.8-houe/src/org/tela_botanica/public
New file
Property changes:
Added: svn:ignore
+*
/branches/v2.8-houe/src/org/tela_botanica/cel-test.gwt.xml
New file
0,0 → 1,10
<module rename-to="org.tela_botanica.cel2">
<!--
http://stackoverflow.com/questions/1011863/how-do-i-speed-up-the-gwt-compiler
http://code.google.com/p/google-web-toolkit/source/browse/trunk/user/src/com/google/gwt/useragent/UserAgent.gwt.xml
http://www.gwtproject.org/doc/latest/DevGuideOrganizingProjects.html#DevGuideModuleXml
-->
<inherits name="org.tela_botanica.cel2" />
<set-property name="user.agent" value="gecko1_8" />
<set-property name="locale" value="default" />
</module>
/branches/v2.8-houe/src/org/tela_botanica/cel2.gwt.xml
New file
0,0 → 1,25
<module>
 
<!-- Inherit the core Web Toolkit stuff. -->
<inherits name='com.google.gwt.user.User'/>
<!-- Inherit the default GWT style sheet. You can change -->
<!-- the theme of your GWT application by uncommenting -->
<!-- any one of the following lines. -->
<inherits name='com.google.gwt.user.theme.standard.Standard'/>
<!-- <inherits name='com.google.gwt.user.theme.chrome.Chrome'/> -->
<!-- <inherits name='com.google.gwt.user.theme.dark.Dark'/> -->
 
<!-- Other module inherits -->
<!-- Parsing JSON -->
<inherits name='com.google.gwt.json.JSON' />
<!-- cartes -->
<inherits name="com.google.maps.gwt.GoogleMaps" />
<inherits name='com.gwtext.GwtExt'/>
<inherits name='com.gwtextux.GwtExtUx' />
<!-- Specify the app entry point class. -->
<entry-point class='org.tela_botanica.client.cel2'/>
</module>