Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 1489 → Rev 1547

/branches/v1.6-croc/src/org/tela_botanica/client/vues/MiniBarrePaginationVue.java
New file
0,0 → 1,322
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);
Window.alert("la nouvelle taille est :"+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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/image/BarreNotationVue.java
New file
0,0 → 1,227
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;
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();
}
 
}
 
}
 
/**
* 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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java
New file
0,0 → 1,588
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
*/
private Tree donneesDates = new Tree();
/**
* 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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java
New file
0,0 → 1,640
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.event.GridListenerAdapter;
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} , {"observations liées", 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()) ;
}
}) ;
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 la selection d'observations sur une image 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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java
New file
0,0 → 1,636
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
 
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.Component;
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.HorizontalLayout;
import com.gwtext.client.widgets.layout.VerticalLayout;
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;
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public FenetreGestionMotsCles() {
// on crée le panel
setTitle("Mots clés");
this.setLayoutData(new VerticalLayout());
 
// 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);
Panel panelIntermediaire = new Panel();
panelIntermediaire.setLayoutData(new VerticalLayout());
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);
this.add(panelBoutons);
arbreMotsCles.setHeight("338px");
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);
 
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners() {
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);
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(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());
}
// 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());
}
}
 
}
 
// 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) {
 
// on met l'ajout du noeud à vrai
ajoutNoeud = true;
// on crée un nouveau noeud vide
TreeNode nd = new TreeNode("");
nd.setCls("x-view-treenode-keyword");
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] = genererIdMotCle(nd);
nd.setId(usObject[1]);
nd.setUserObject(usObject);
// l'identifiant d'un noeud c'est son hashcode
// l'objet associé au noeud contient aussi son identifiant
 
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
// enfin on place le curseur et on fait apparaitre le champ d'édition
// pour que l'utilisateur nomme son mot clé
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) {
 
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);
getArbreMotsCles().getNodeById(nodeId).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);
}
});
}
}
}
 
private String genererIdMotCle(TreeNode nd) {
return "" + (nd.hashCode() + (Math.random() * 10000));
}
/**
* 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/v1.6-croc/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;
}
}
Property changes:
Added: svn:mergeinfo
/branches/v1.6-croc/src/org/tela_botanica/client/vues/ListeUtilisateurAdminVue.java
New file
0,0 → 1,215
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.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
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;
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);
// commune.setPageSize(10); // Ne fonctionne pas
listeUtil.setItemSelector("div.search-item-utilisateur");
listeUtil.setTypeAhead(true);
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();
}
});
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:
obtenirListeUtilisateur();
break;
}
}
});
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);
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/v1.6-croc/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
New file
0,0 → 1,498
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
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;
 
/**
* 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() {
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());
}
// 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());
}
 
}
 
// 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());
}
 
});
 
// 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());
} 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) {
 
// on met l'ajout du noeud à vrai
ajoutNoeud = true;
// on crée un nouveau noeud vide
TreeNode nd = new TreeNode("");
nd.setCls("x-view-treenode-keyword");
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] = genererIdMotCle(nd);
nd.setId(usObject[1]);
nd.setUserObject(usObject);
// l'identifiant d'un noeud c'est son hashcode
// l'objet associé au noeud contient aussi son identifiant
 
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
// enfin on place le curseur et on fait apparaitre le champ d'édition
// pour que l'utilisateur nomme son mot clé
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();
}
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;
cocherMotsCles(tableauMotsClesEnCours);
}
}
 
private String genererIdMotCle(TreeNode nd) {
return "" + (nd.hashCode() + (Math.random() * 10000));
}
/**
* 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);
}
 
}
}
}
}
/branches/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
New file
0,0 → 1,453
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 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
copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
.getRootNode());
 
// 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;
}
 
/**
* 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] +prefixe);
child.setUserObject(usObj);
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;
}
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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java
New file
0,0 → 1,764
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 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;
 
/**
* 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) {
 
// 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 notifie le médiateur de l'ajout et on lui passe
// l'arbre
getOMediateur().ajouterMotCleDansArbre(nd,
getArbreMotsCles().getTree());
// et considère l'ajout achevé
ajoutNoeud = false;
}
// si c'est noeud déjà existant
else {
if (modifNoeud) {
// 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;
}
}
 
}
 
// 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);
}
});
 
}
/**
* 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());
}
} 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) {
 
// on met l'ajout du noeud à vrai
ajoutNoeud = true;
// on crée un nouveau noeud vide
TreeNode nd = new TreeNode("");
nd.setCls("x-view-treenode-keyword");
// 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] = genererIdMotCle(nd);
nd.setId(usObject[1]);
nd.setUserObject(usObject);
// l'identifiant d'un noeud c'est son hashcode
// l'objet associé au noeud contient aussi son identifiant
 
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
// enfin on place le curseur et on fait apparaitre le champ d'édition
// pour que l'utilisateur nomme son mot clé
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) {
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) {
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;
}
 
// 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;
}
}
}
 
private String genererIdMotCle(TreeNode nd) {
double IdMC = (nd.hashCode() + ((Math.random() * 10000) + 1));
return ""+IdMC;
}
/**
* 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.setUserObject(usObj);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
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) {
val += ";"+noeuds[i].getId();
}
}
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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java
New file
0,0 → 1,683
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
*/
private Tree donneesDates = new Tree();
/**
* 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/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java
New file
0,0 → 1,71
package org.tela_botanica.client.vues.observation.indicateurs;
 
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 refTaxVersion = "";
private String numTax = "";
private String efloreBaseUrl = "";
private Label titreLien = new Label("Voir la fiche eflore");
public LienExterneVue(ObservationMediateur om) {
oMediateur = om;
refTax = om.getRefTaxSelectionne().getCode();
refTaxVersion = om.getRefTaxSelectionne().getVersionCourte();
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) {
if(nouvelleDonnees instanceof String && !((String)nouvelleDonnees).trim().equals("")) {
if(!titreLien.isVisible()) {
titreLien.setVisible(true);
}
numTax = (String)nouvelleDonnees;
} else {
titreLien.setVisible(false);
}
}
 
}
/branches/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java
New file
0,0 → 1,212
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) {
image.setUrl("ill_taxon.png") ;
image.setPixelSize(150, 150);
}
else {
image.setUrl(urlImage);
verifierEtRetaillerImage();
}
}
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/v1.6-croc/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java
New file
0,0 → 1,89
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&eacute;l&eacute;charger le mod&egrave;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() + "/InventoryImportExcel");
form.addSubmitCompleteHandler(new SubmitCompleteHandler() {
@Override
public void onSubmitComplete(SubmitCompleteEvent event) {
nPan.close();
com.google.gwt.user.client.Window.alert(""+event.getResults()+" observations créees");
oMediateur.obtenirDernierePageObservation();
}
});
}
public void afficher() {
nPan.show();
}
}
/branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java
New file
0,0 → 1,897
package org.tela_botanica.client.vues.observation;
 
 
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.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.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.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.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 lieuObservation;
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;
/**
* 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>");
barreActions.addButton(publier);
barreActions.addButton(privatiser);
barreActions.addSpacer();
barreActions.addButton(supprimer);
barreActions.addSpacer();
barreActions.addButton(importer);
barreActions.addSpacer();
barreActions.addItem(exporter);
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);
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, 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, abondanceObservation, phenologieObservation, lieuObservation, dateObservation, ordreObservation};
return cm;
}
 
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
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();
}
});
}
});
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()][11];
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.getAbondance();
observationData[i][6] = obs.getPhenologie();
observationData[i][7] = Util.formaterLieu(obs, modeleLieu);
observationData[i][8] = obs.getDate();
observationData[i][9] = obs.getNumeroOrdre();
observationData[i][10] = 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) {
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)
{
observationMediateur.obtenirNombreObservation() ;
}
if(!getTailleInitialisee()) {
if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
doLayout();
setTailleInitialisee();
}
}
}
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 defAbondanceObservation = new StringFieldDef("abondance");
FieldDef defPhenologieObservation = new StringFieldDef("phenologie");
FieldDef defLieuObservation = new StringFieldDef("lieu_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, defAbondanceObservation,
defPhenologieObservation, defLieuObservation, 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();
// 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) ;
 
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;
}
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;
}
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mergeinfo
/branches/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java
New file
0,0 → 1,1984
package org.tela_botanica.client.vues.observation;
 
// TODO Detecter redim et supprimer ajuster
 
import java.util.Date;
import java.util.Iterator;
 
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.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.Util;
 
import com.google.gwt.maps.client.geom.LatLng;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
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.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.SimpleStore;
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, 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 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, abondance, identification, referentiel, phenologie";
}
return TOUT.toString();
}
};
private String formatDate = null ;
private Button boutonOK = new Button("Créer");
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 boolean modification = false ;
private Toolbar bt = null ;
private final String VALEURS_MULTIPLES = "(Valeurs multiples)";
private final String modeleMessageModif = "commune:lieu-dit:station:milieu:latitude:longitude: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;
/**
* Combobox permettant de selectionner le mode
* modification ou bien création
*/
private ComboBox selecteurMode = new ComboBox();
Store storeMode = null ;
 
/**
* Booleen d'instanciation
*/
boolean estInstancie = false ;
 
private Panel panneauIntermediaire;
 
private Panel panneauPremierColonne;
 
private Panel panneauSecondeColonne;
 
private boolean masseModification =false ;
 
private TextField longitude;
 
private TextField latitude;
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;
 
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;
/**
* 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);
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);
//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", 200);
date.setAllowBlank(true);
formatDate = "d/m/Y";
date.setFormat(formatDate) ;
date.setTitle("Date de l'observation au format jj/mm/aaaa");
//date.setTabIndex(5);
panneauPremierColonne.add(date, new AnchorLayoutData("55%"));
// 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);
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("50%"));
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);
panneauPremierColonne.add(selecteurAbondance, new AnchorLayoutData("50%"));
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);
panneauSecondeColonne.add(selecteurCertitude, new AnchorLayoutData("50%"));
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);
panneauSecondeColonne.add(selecteurStadePheno, new AnchorLayoutData("50%"));
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);
Object[][] mode = {{"création",false} , {"modification", 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("création") ;
selecteurMode.setEditable(false) ;
selecteurMode.setCls("x-selec-crea") ;
bt = new Toolbar() ;
bt.addSpacer() ;
bt.addText("Mode de saisie ") ;
bt.addField(selecteurMode) ;
if (Ext.isIE()) {
panneauPremierColonne.setButtonAlign(Position.RIGHT);
panneauPremierColonne.addButton(boutonOK);
panneauSecondeColonne.setButtonAlign(Position.LEFT);
panneauPremierColonne.addButton(boutonAnnuler);
}
else {
panneauFormulaire.addButton(boutonOK);
panneauFormulaire.addButton(boutonAnnuler);
}
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")) ;
}
});
this.add(panneauFormulaire) ;
this.setTopToolbar(bt) ;
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();
}
});
// on ajoute les listeners
ajouterListeners() ;
saisieTabindex();
}
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,LatLng.newInstance(coord[0], coord[1]));
}
}
};
ajouterListenerChampEvenementsClavier(commune, listenerConfigCommune);
ajouterListenerChampEvenementsClavier(date);
ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo);
ajouterListenerChampEvenementsClavier(espece, listenerConfigEspece);
ajouterListenerChampEvenementsClavier(comment);
ajouterListenerChampEvenementsClavier(latitude);
ajouterListenerChampEvenementsClavier(longitude);
ajouterListenerChampEvenementsClavier(selecteurAbondance);
ajouterListenerChampEvenementsClavier(selecteurCertitude);
ajouterListenerChampEvenementsClavier(selecteurStadePheno);
ajouterListenerChampsCombobox();
boutonOK.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(modification) {
if(masseModification) {
modifierObservationEnMasse(null);
} else {
modifierObservation() ;
}
}
else {
ajouterObservation();
}
}
});
boutonAnnuler.addListener(new ButtonListenerAdapter() {
@Override
public void onClick(Button button, EventObject e) {
if(modification)
{
supprimerObservation() ;
}
else
{
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(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(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(modification) {
if(masseModification) {
modifierObservationEnMasse(champs);
} else {
modifierObservation();
}
raz(champs);
}
else {
ajouterObservation();
raz(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 ;
afficherDetailsObservation(obs) ;
}
if(nouvelleDonnees instanceof ListeObservation) {
ListeObservation listeObs = (ListeObservation)nouvelleDonnees;
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]);
setModification("false");
}
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());
}
commune.setValue(nCommune);
communeModifiee = true;
}
 
private void rafraichirCommuneEtCoord(EntiteGeographiqueObservation infosCom) {
// on ne remplace la commune que si le champ était vide
if(commune.getRawValue() == null || commune.getRawValue().equals("")) {
rafraichirCommune(infosCom);
}
 
if(infosCom.getLat() != null && !infosCom.getLat().equals("")) {
latitude.setValue(infosCom.getLat());
}
 
if(infosCom.getLon() != null && !infosCom.getLon().equals("")) {
longitude.setValue(infosCom.getLon());
}
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(!Util.verifierDateFormatCel(date.getRawValue()) && !date.getRawValue().equals("")) {
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.setAbondance(getAbondance());
obs.setCertitude(getCertitude());
obs.setPhenologie(getPhenologie());
obs.setReferentielTaxo(Ontologies.getInfosReferentielNomParCode(referentielTaxo).getCodeVersionComplet());
observationMediateur.ajouterObservation(obs);
}
 
private void modifierObservation() {
if(!Util.verifierDateFormatCel(date.getRawValue()) && !date.getRawValue().equals("")) {
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.setAbondance(getAbondance());
obs.setCertitude(getCertitude());
obs.setPhenologie(getPhenologie());
obs.setReferentielTaxo(getReferentielTaxo());
observationMediateur.modifierObservation(obs);
 
selecteurMode.setValue("création");
setModification("false");
}
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 abondanceM = null;
String certitudeM = null;
String referentielTaxoM = null;
String phenologieM = null;
String champs = modeleMessageModif;
if(communeModifiee) {
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) {
lieuDitM = lieudit.getText();
}else {
champs = champs.replaceAll(":lieu-dit", "");
}
if(stationModifiee) {
stationM = station.getText();
}else {
champs = champs.replaceAll(":station", "");
}
 
if(milieuModifie) {
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) {
especeM = espece.getText();
numNomSelM = numeroNom;
}else {
champs = champs.replaceAll(":espece", "");
}
 
if(commModifie) {
commM = comment.getText();
}else {
champs = champs.replaceAll(":commentaire", "");
}
if(latModifiee) {
latM = latitude.getText();
}else {
champs = champs.replaceAll(":latitude", "");
}
if(longModifiee) {
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.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(!obs.getLatitude().equals("null") && !obs.getLatitude().equals("000null")
&& !obs.getLongitude().equals("null") && !obs.getLongitude().equals("000null")) {
latitude.setValue(obs.getLatitude()) ;
longitude.setValue(obs.getLongitude()) ;
}
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();
selecteurReferentielTaxo.setValue(referentielTaxo);
} else {
referentielTaxo = "";
selecteurReferentielTaxo.setRawValue(VALEURS_MULTIPLES);
}
}
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 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();
departement ="";
espece.reset();
selecteurAbondance.clearValue();
selecteurCertitude.clearValue();
selecteurReferentielTaxo.clearValue();
selecteurStadePheno.clearValue();
referentielTaxo = "";
numeroNom = "" ;
numeroOrdre = "";
afficherIndicationCommune(null);
break;
 
}
}
private void setModification(String mode)
{
if(mode.equals("true")) {
 
boutonOK.setText("Modifier") ;
setTitle("Modification") ;
boutonAnnuler.setText("Supprimer") ;
modification = true ;
selecteurMode.removeClass("x-selec-crea") ;
selecteurMode.setCls("x-selec-modif") ;
observationMediateur.onModeModification();
}
else
{
boutonOK.setText("Créer") ;
setTitle("Saisir") ;
boutonAnnuler.setText("Réinitialiser") ;
modification = false ;
selecteurMode.removeClass("x-selec-modif") ;
selecteurMode.setCls("x-selec-crea") ;
observationMediateur.onModeCreation();
}
}
/**
* renvoie vrai si on est en mode modification, faux si on est en mode création
* @return
*/
public boolean getModification()
{
return modification ;
}
/**
* renvoie vrai si on est en mode modification de masse, faux sinon
* @return
*/
public boolean getMasseModification()
{
return masseModification ;
}
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 setMasseModification(boolean masseModification) {
this.masseModification = masseModification;
if(masseModification) {
reinitialiserValeurModifiees();
}
}
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 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());
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.setAbondance(abondance);
obs.setCertitude(certitude);
obs.setReferentielTaxo(referentielTaxo);
obs.setPhenologie(phenologie);
rafraichir(obs, false);
}
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;
abondanceModifiee = false;
certitudeModifiee = false;
referentielTaxoModifie = false;
phenologieModifiee = false;
}
public void saisieTabindex()
{
selecteurMode.setTabIndex(0);
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);
comment.setTabIndex(10);
date.setTabIndex(11);
espece.setTabIndex(12);
selecteurCertitude.setTabIndex(13);
selecteurAbondance.setTabIndex(14);
selecteurStadePheno.setTabIndex(15);
boutonOK.setTabIndex(16);
boutonAnnuler.setTabIndex(17);
}
private void obtenirInformationCoord() {
if(coordonneesValides() != null) {
observationMediateur.obtenirInformationCoord(LatLng.newInstance(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(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/v1.6-croc/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/v1.6-croc/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/v1.6-croc/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java
New file
0,0 → 1,358
package org.tela_botanica.client.vues.observation;
 
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.observation.ObservationMediateur;
import org.tela_botanica.client.util.Util;
 
import com.google.gwt.maps.client.InfoWindow;
import com.google.gwt.maps.client.InfoWindowContent;
import com.google.gwt.maps.client.MapType;
import com.google.gwt.maps.client.MapWidget;
import com.google.gwt.maps.client.Maps;
import com.google.gwt.maps.client.control.LargeMapControl;
import com.google.gwt.maps.client.event.MapClickHandler;
import com.google.gwt.maps.client.event.MapZoomEndHandler;
import com.google.gwt.maps.client.event.MarkerClickHandler;
import com.google.gwt.maps.client.event.MarkerDragEndHandler;
import com.google.gwt.maps.client.event.MarkerDragStartHandler;
import com.google.gwt.maps.client.geom.LatLng;
import com.google.gwt.maps.client.overlay.Marker;
import com.google.gwt.maps.client.overlay.MarkerOptions;
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;
 
public class CartographieObservationVue extends Panel implements Rafraichissable {
 
private String id = "cartographie_observation";
private ObservationMediateur oMediateur = null;
Panel panneauCarto = null;
private MapWidget map;
private boolean carteAjoutee = false;
private boolean requeteEnCours = false;
String valeurCommune = "Bourges";
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 listenerInitialise = false;
 
public CartographieObservationVue(ObservationMediateur om) {
oMediateur = om;
setHeader(false);
setAutoWidth(true);
setPaddings(10);
 
panneauCarto = new Panel();
panneauCarto.setLayout(new FitLayout());
 
setLayout(new RowLayout());
 
add(panneauExplication, new RowLayoutData(12));
add(panneauCarto, new RowLayoutData());
if(!carteAjoutee) {
Maps.loadMapsApi(Configuration.getCleGoogleMaps(), "2", false, new Runnable() {
@Override
public void run() {
initialiserCarte(false);
}
});
}
addListener(new ContainerListenerAdapter() {
@Override
public void onAfterLayout(Container c) {
if(carteAjoutee) {
panneauCarto.setHeight("100%");
if((panneauCarto.getHeight() - 20) > map.getSize().getHeight()) {
map.setSize(map.getSize().getWidth()+"px", (panneauCarto.getHeight() - 20)+"px");
}
panneauCarto.doLayout();
panneauCarto.expand();
}
}
});
panneauCarto.setAutoHeight(true);
}
public void setTailleCarte(int hauteur, int largeur) {
map.setSize(largeur+"px", (hauteur+"px"));
}
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);
}
 
public void mettreAJourInfos(final LatLng pointNouvelleCommune, String infosComplementaires, int zoom) {
 
if (!carteAjoutee) {
initialiserCarte(true);
}
 
pointCommune = pointNouvelleCommune;
map.clearOverlays();
Marker nmk = fabriquerMarqueur(pointCommune, infosComplementaires);
map.addOverlay(nmk);
afficherInfoMarker(nmk);
recentrerCarte();
}
 
public void initialiserCarte(boolean commune) {
centreFrance = LatLng.newInstance(47.0504, 2.2347);
pointCommune = centreFrance;
map = new MapWidget(pointCommune, niveauZoom);
panneauCarto.add(map);
panneauCarto.doLayout();
info = map.getInfoWindow();
if(!commune) {
fabriquerMarqueurIndication();
}
map.setZoomLevel(6);
map.checkResizeAndCenter();
map.setUIToDefault();
map.addControl(new LargeMapControl());
map.setCurrentMapType(MapType.getHybridMap());
carteAjoutee = true;
panneauCarto.doLayout();
map.addMapClickHandler(new MapClickHandler() {
 
@Override
public void onClick(MapClickEvent event) {
//TODO : quoi faire du double clic ?
obtenirInfosCommunes(event.getLatLng());
}
});
map.addMapZoomEndHandler(new MapZoomEndHandler() {
 
@Override
public void onZoomEnd(MapZoomEndEvent event) {
niveauZoom = event.getNewZoomLevel();
}
});
}
public void fabriquerMarqueurIndication() {
Marker marker = fabriquerMarqueur(pointCommune,"");
map.addOverlay(marker);
info.open(marker, new InfoWindowContent("<div id=\"info_contenu\">"+
"Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />"
+"longitude="
+ marker.getLatLng().getLongitude() + "<br />latitude="
+ marker.getLatLng().getLatitude() + "</div>"));
}
 
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;
}
bouton.addListener("click", new EventCallback() {
@Override
public void execute(EventObject e) {
EntiteGeographiqueObservation infosCommune = new EntiteGeographiqueObservation(codeCommune,valeurCommune,null,null);
infosCommune.setLat(pointCommune.getLatitude()+"");
infosCommune.setLon(pointCommune.getLongitude()+"");
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.newInstance(lat, lon);
valeurCommune = infos.getZoneGeo();
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.newInstance();
options.setDraggable(true);
final Marker marker = new Marker(pointMarqueur, options);
marker.addMarkerDragEndHandler(new MarkerDragEndHandler() {
@Override
public void onDragEnd(MarkerDragEndEvent event) {
masquerChargement(true);
obtenirInfosCommunes(marker.getLatLng());
}
 
});
 
marker.addMarkerDragStartHandler(new MarkerDragStartHandler() {
@Override
public void onDragStart(MarkerDragStartEvent event) {
info.setVisible(false);
}
});
marker.addMarkerClickHandler(new MarkerClickHandler() {
 
@Override
public void onClick(MarkerClickEvent event) {
if(info.isVisible()) {
info.close();
} else {
afficherInfoMarker(marker);
}
}
});
return marker;
}
 
public void recentrerCarte() {
if(this.getWidth() > 12 && this.getHeight() > 24) {
map.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 24)+"px");
panneauCarto.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 12)+"px");
}
map.setCenter(pointCommune, niveauZoom);
map.checkResizeAndCenter();
}
 
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.getLatLng().getLongitude() == 0 && marker.getLatLng().getLatitude() == 0) {
LatLng point = centreFrance;
marker.setLatLng(point);
niveauZoom = 6;
}
contenuMarker = "<div id=\"info_contenu\">"+
"Aucune commune française trouvée à cet emplacement <br />"
+"Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />"
+"longitude="
+ marker.getLatLng().getLongitude() + "<br />latitude="
+ marker.getLatLng().getLatitude() + "</div>";
} else {
contenuMarker = ""
+valeurCommune+" ("+codeCommune+")<br />"
+"longitude="
+ marker.getLatLng().getLongitude() + "<br />latitude="
+ marker.getLatLng().getLatitude() ;
}
info.open(marker, new InfoWindowContent(""
+ contenuMarker
+ htmlBoutonOk));
recentrerCarte();
ajouterListenerBouton("okMap");
}
public LatLng getCentreFrance() {
return LatLng.newInstance(47.0504, 2.2347);
}
 
}
/branches/v1.6-croc/src/org/tela_botanica/client/vues/EtatConnexionVue.java
New file
0,0 → 1,280
/**
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.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;
private String liens = "<div id=\"liensExt\"><a href=\"#\" id=\"lienAide\">Aide</a></div>" ;
/**
* Booleen indiquant si utilisateur 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("etatConnexion");
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/v1.6-croc/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
New file
0,0 → 1,202
/**
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;
 
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
*
*/