New file |
0,0 → 1,631 |
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.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; |
|
/** |
* 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","id_obs","plante","date","lieu"}, 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("Numero", "id_obs", 50, true, colRend), |
new ColumnConfig("Taxon", "plante", 145, true, colRend), |
new ColumnConfig("Date", "date", 68, true, dateRend), |
new ColumnConfig("Lieu", "lieu", 145, 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.getNumeroOrdre(); |
listeObs[i][1] = obs.getTransmis(); |
listeObs[i][2] = obs.getNomSaisi(); |
listeObs[i][3] = obs.getDate() ; |
listeObs[i][4] = obs.getLocalite(); |
|
i++ ; |
} |
|
store = new SimpleStore(new String[]{"id_obs","transmis","plante","date","lieu"}, 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 |