Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 2756 → Rev 2757

/branches/v2.23-rouleau/src/org/tela_botanica/client/vues/image/ListeImageVue.java
New file
0,0 → 1,795
package org.tela_botanica.client.vues.image;
 
import java.util.HashMap;
 
import org.tela_botanica.client.i18n.Msg;
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.modeles.objets.Ontologies;
import org.tela_botanica.client.util.Util;
import org.tela_botanica.client.vues.BarrePaginationVue;
 
import com.google.gwt.user.client.Timer;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.SortDir;
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.GridHeaderListenerAdapter;
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;
private SortDir directionTri;
 
private String champTri;
private boolean triActif;
/**
* 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(Msg.get("images"));
bt.setTaillePageParDefaut(50);
setBottomToolbar(bt);
directionTri = SortDir.ASC;
 
// on construit le modèle de colonnes
numImage = new ColumnConfig(Msg.get("numero"), "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(" ", "transmis", 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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("nom-associe"), "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);
 
RecordDef rd = new RecordDef(ImageMediateur.getDefinitionsChampsGrilleImages());
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.addGridHeaderListener(new GridHeaderListenerAdapter() {
@Override
public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {
triActif = true;
Timer t = new Timer() {
@Override
public void run() {
enregistrerEtatTri();
// Trier ne change pas le nombre de page, on peut donc se passer d'un appel
// au comptage (ce serait mieux si ces deux appels étaient combinés)
iMediateur.obtenirPhotoGalerieSansCalculerPages(ListeImageVue.this);
}
};
// Le changement de tri n'est pas immédiat et si on recharge le liste tout de suite
// on a l'ancien tri et pas le nouveau (200 millisecondes suffisent et ne se voient pas)
// #mondeDeMerde
t.schedule(200);
}
});
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(Msg.get("glissez-deposer-images-obs")) ;
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.sort(champTri, directionTri);
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;
}
private void enregistrerEtatTri() {
if(triActif) {
this.directionTri = st.getSortState().getDirection();
this.champTri = st.getSortState().getField();
}
}
public String renvoyerTri() {
String tri = "ordre";
if(triActif) {
HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleImageChampsTri();
if(corr.containsKey(champTri)) {
tri = corr.get(champTri);
}
}
return tri;
}
 
public String renvoyerDirectionTri() {
String triDir = "ASC";
try {
triDir = (triActif) ? directionTri.getDirection() : "ASC";
} catch (Exception e) {
triDir = "ASC";
}
return triDir;
}
}
Property changes:
Added: svn:mergeinfo