Subversion Repositories eFlore/Applications.cel

Compare Revisions

Problem with comparison.

Ignore whitespace Rev HEAD → Rev 638

/trunk/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java
New file
0,0 → 1,634
package org.tela_botanica.client.vues.image;
 
import java.util.Iterator;
 
import org.tela_botanica.client.Util;
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.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
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.grid.event.GridRowListenerAdapter;
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() {
 
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
{
}
return value.toString() ;
}
} ;
Renderer dateRend = new Renderer() {
 
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","id_obs"}, getObs());
ColumnConfig[] columns = {
new ColumnConfig("", "transmis", 30, true, new Renderer() {
 
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", "id_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() {
 
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() {
 
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)
{
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 ;
}
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof ListeObservation)
{
if(this.getView() != null)
{
ListeObservation data = (ListeObservation)nouvelleDonnees ;
//Window.alert(data.size()+"");
String[][] listeObs = new String[data.size()][5] ;
int i = 0 ;
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=(Observation) 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();
i++ ;
}
store = new SimpleStore(new String[]{"transmis","plante","date","lieu","id_obs"}, listeObs);
store.load();
this.reconfigure(store, colModel) ;
}
else
{
addListener(new ContainerListenerAdapter() {
public void onShow(Component c)
{
obtenirNombreMiniListeObservations() ;
}
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[][]{
} ;
}
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
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());
}
 
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
*/
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