Subversion Repositories eFlore/Archives.cel-v2

Compare Revisions

Ignore whitespace Rev 30 → Rev 31

/trunk/src/org/tela_botanica/client/image/ImageMediateur.java
15,6 → 15,8
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.Store;
41,7 → 43,7
public class ImageMediateur {
/**
* booleen qui verifie l'unicite de l'instance
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false ;
50,8 → 52,7
*/
private ImageModele iModele = null ;
// Widget crées par le médiateur
 
/**
* panneau principal des images (onglet "images")
*/
117,6 → 118,7
*/
private ImageMediateur()
{
// quelques variables de position pour les borderlayouts
final BorderLayoutData regionNord = new BorderLayoutData(
RegionPosition.NORTH) ;
128,49 → 130,67
regionEst.setSplit(true);
 
// on crée un modèle
iModele = ImageModele.Instance(this);
// et on demande l'arbre des mots clés
iModele.initialiserArbreMotsCles() ;
// on gère la mise en page du panneau principal
panneauPrincipalImage.setLayout(new BorderLayout());
// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
panneauMenuEtOngletsImage = new Panel() ;
panneauMenuEtOngletsImage.setLayout(new BorderLayout()) ;
// le panneau à onglet qui contient les trois vues
ongletsImage = new TabPanel();
// la galerie
galerieImage = new GalerieImageVue(this) ;
// la liste des images
Panel panneauListeImage = new Panel("Liste");
listeImage = new ListeImageVue(this);
panneauListeImage.setLayout(new FitLayout());
panneauListeImage.add(listeImage);
// le panneau zoom
zoomImage = new ZoomImageVue(this);
// on ajoute les panneaux au panneau à onglets
ongletsImage.add(galerieImage);
ongletsImage.add(zoomImage);
ongletsImage.add(panneauListeImage);
// on crée les menu et la barre de vue
menuImageVue = new MenuImageVue(this) ;
barreOutilsVue = new BarreOutilsVue(this) ;
// on initialise le volet qui contient les mots clés
detailsEtMotsCles.setWidth("25%");
detailsEtMotsCles.setAnimCollapse(true);
detailsEtMotsCles.setTitleCollapse(true);
detailsEtMotsCles.setCollapsible(true);
// on crée le panneau conteneur des métadonnées et infos
metadonneesIptcExif = new PanneauMetadonneesVue(this) ;
// et on l'inclut dans le volet approprié
detailsEtMotsCles.add(metadonneesIptcExif) ;
// on ajoute la barre de vue au nord du panneau qui contient menu et onglets d'images
panneauMenuEtOngletsImage.add(barreOutilsVue,regionNord) ;
// les onglets au centre
panneauMenuEtOngletsImage.add(ongletsImage,regionCentre);
// on ajoute le panneau qui contient le menu et les onglets d'images au centre
panneauPrincipalImage.add(panneauMenuEtOngletsImage,regionCentre);
// et le panneau de métadonnées et d'info sur le coté droit
panneauPrincipalImage.add(detailsEtMotsCles,regionEst);
}
/**
* @param selection the selection to set
* @param change la valeur du booleen de selection
*/
public void setSelection(boolean selection) {
this.selection = selection;
177,12 → 197,16
}
 
/**
* @return the selection
* @return la valeur du booleen de selection
*/
public boolean isSelection() {
return selection;
}
 
/**
* Retourne une instance de manière unique
* @return l'instance du médiateur
*/
public static ImageMediateur Instance()
{
if(!estInstancie)
196,23 → 220,43
}
}
/**
* Renvoie l'identifiant de l'utilisateur en cours
* @return l'identifiant de l'utilisateur
*/
public String getIdentifiant()
{
return "0" ;
}
 
/**
* Accesseur pour le modèle associé au médiateur
* @return le modèle associé
*/
public ImageModele getIModele() {
return iModele;
}
 
/**
* Accesseur pour le panneau principal
* @return le panneau principal
*/
public Panel getPanneauPrincipalImage() {
return panneauPrincipalImage;
}
 
/**
* Accesseur pour le panneau à onglets
* @return le panneau à onglets
*/
public TabPanel getOngletsImage() {
return ongletsImage;
}
 
/**
* Accesseur pour la galerie d'images
* @return la galerie d'image
*/
public GalerieImageVue getGalerieImage() {
return galerieImage;
}
221,16 → 265,25
return listeImage;
}
 
/**
* Accesseur pour le panneau "zoom"
* @return le panneau zoom
*/
public ZoomImageVue getZoomImage() {
return zoomImage;
}
 
/**
* Accesseur pour le panneau détails et mot clés
* @return le panneau détails et mots clés
*/
public Panel getDetailsEtMotsCles() {
return detailsEtMotsCles;
}
/**
* @return the estInstancie
* Accesseur pour le booleen d'instanciation
* @return le booleen d'instanciation
*/
public static boolean isEstInstancie() {
return estInstancie;
237,7 → 290,8
}
 
/**
* @return the panneauMenuEtOngletsImage
* Accesseur pour la panneaèu contenant le menu et les onglets images
* @return le panneauMenuEtOngletsImage
*/
public Panel getPanneauMenuEtOngletsImage() {
return panneauMenuEtOngletsImage;
244,6 → 298,7
}
 
/**
* Accesseur pour le menu
* @return the menuImageVue
*/
public MenuImageVue getMenuImageVue() {
251,6 → 306,7
}
 
/**
* Accesseur pour la barre d'outils
* @return the barreOutilsVue
*/
public BarreOutilsVue getBarreOutilsVue() {
258,6 → 314,7
}
 
/**
* Accesseur pour le panneau infos et métadonnées
* @return the metadonneesIptcExif
*/
public PanneauMetadonneesVue getMetadonneesIptcExif() {
265,7 → 322,8
}
 
/**
* @return the dernierIndexOnglet
* Renvoie l'index du dernier onglet sélectionné
* @return l'index du dernier onglet
*/
public int getDernierIndexOnglet() {
return dernierIndexOnglet;
272,7 → 330,7
}
/**
*
* Renvoie la vue sélectionné par l'utilisateur
* @return la vue selectionnée par l'utilisateur
*/
public VueListable getVueSelectionnee()
306,7 → 364,41
}
/**
* met a jour les données provenant du modèle et synchronise les vues entre elles
* Renvoie l'identifiant de la vue en cours
* @return l'identifiant de la vue en cours de visualisation
*/
public String getIdVueSelectionnee()
{
Panel active = ongletsImage.getActiveTab() ;
if(active != zoomImage)
{
if(active == galerieImage)
{
return galerieImage.getId() ;
}
else
{
return listeImage.getId() ;
}
}
else
{
if(dernierIndexOnglet == 0)
{
return galerieImage.getId() ;
}
else
{
return listeImage.getId() ;
}
 
}
}
/**
* Met a jour les données provenant du modèle et synchronise les vues entre elles
* @param o données de mises a jour pour les vues
* @param r le refraichissable qui a demandé la mise a jour
*/
342,6 → 434,7
}
aucuneSelection() ;
demasquerChargement() ;
}
/**
373,6 → 466,10
getIModele().obtenirMotsClesId(r, id) ;
}
/**
* Envoie au modèle une demande pour obtenir l'arbre des mots clés
* @param r le raffraichissable qui a demandé la mise à jour
*/
public void obtenirArbreMotsCles(Rafraichissable r)
{
getIModele().obtenirArbreMotCle(r) ;
391,6 → 488,10
getIModele().mettreAJourCacheImage(commentaires, date, ids) ;
}
/**
* Met à jour l'arbre des mots clés affichés dans le volet de droite à partir de l'arbre passé en paramètre
* @param arbreMC le nouvel arbre des mots clés
*/
public void rafraichirArbreMotsCles(Tree arbreMC)
{
metadonneesIptcExif.getPanneauMotsCles().rafraichir(arbreMC, false) ;
498,6 → 599,7
int storeIndex ;
Record nRec = null ;
// tout d'abord on obtient les index selectionnés suivant la vue
if(getVueSelectionnee() == galerieImage)
{
DataView dv = getGalerieImage().getDView();
631,6 → 733,7
if(com.google.gwt.user.client.Window
.confirm("Supprimer les images selectionnees ?"))
{
masquerChargement() ;
getIModele().supprimerImages(ids) ;
aucuneSelection() ;
}
657,7 → 760,7
}
/**
* reacative les onglet metadonnees et zoom (lors d'une selection alors qu'il n'y en avait pas)
* reactive les onglet metadonnees et zoom (lors d'une selection alors qu'il n'y en avait pas)
*/
public void selection() {
669,6 → 772,12
}
}
 
/**
* Fait apparaitre le menu contextuel de l'arbre des mots clés au niveau d'un noeud donné
* @param n le noeud ou le menu doit apparaitre
* @param ev l'objet contenant les données sur l'évenement
* @param te l'éditeur associé à l'arbre qui permet de modifier les libellés des noeuds
*/
public void montrerContextMenuArbre(final TreeNode n, EventObject ev, final TreeEditor te)
{
Menu mn = new Menu() ;
697,8 → 806,11
}
 
/**
* Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du mot clé
* @param text le texte du mot clé
* @param id l'identifiant du mot clé
*/
public void mettreAjourMotsClesId(String text, String id) {
getIModele().mettreAjourMotsClesId(text, id) ;
705,6 → 817,12
}
 
/**
* Récupère les identifiants des images selectionnés
* et appelle le modèle pour qu'il mette à jour les associations mots clés/images
* @param motsClesEnCours les mots clés à associer aux images selectionnés séparés par une ','
* @param arbreMC l'arbre des mots clés à mettre à jour
*/
public void mettreAjourMotsCles(String motsClesEnCours, Tree arbreMC) {
String[] ids = getGalerieImage().getIdSelectionnees() ;
712,11 → 830,21
}
/**
* Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots clés
* @param n le noeud parent pour l'ajout
* @param arbreMC le nouvel arbre de mots clés à mettre à jour
*/
public void ajouterMotCleDansArbre(TreeNode n,Tree arbreMC)
{
getIModele().ajouterMotCleDansArbre(n, arbreMC) ;
}
 
/**
* Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre dans l'arbre des mots clés
* @param n le noeud à supprimer
* @param arbreMC le nouvel arbre de mots clés à mettre à jour
*/
public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
getIModele().supprimerMotCleDansArbre(n,arbreMC) ;
723,6 → 851,11
}
 
/**
* Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots clés
* @param n le noeud à modifier
* @param arbreMC le nouvel arbre de mots clés à mettre à jour
*/
public void modifierMotCleDansArbre(TreeNode n , Tree arbreMC) {
getIModele().modifierMotCleDansArbre(n,arbreMC) ;
729,16 → 862,97
}
/**
* Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans l'arbre des mots clés
* @param n le noeud à déplacer
* @param arbreMC le nouvel arbre de mots clés à mettre à jour
*/
public void deplacerMotCleDansArbre(TreeNode n , Tree arbreMC) {
getIModele().deplacerMotCleDansArbre(n, arbreMC) ;
}
 
/**
* initialise les mots clés cochés par rapport aux images sélectionnées
*/
public void initialiserMotsCleCoches() {
obtenirMotsClesId(metadonneesIptcExif.getPanneauMotsCles(), getGalerieImage().getIdSelectionnees()[0]) ;
}
 
/**
* Appelle le modèle pour lui demander les données d'une page à afficher
* @param pageCourante le numéro de page à affciher
*/
public void changerNumeroPage(int pageCourante) {
// on met le mesage d'attente
masquerChargement() ;
// on appelle le modèle
getIModele().changerNumeroPage(pageCourante) ;
// et met à jour les numéros de page dans les barre d'outils
getGalerieImage().getToolBarVue().changerPageCourante(pageCourante);
getListeImage().getToolBarVue().changerPageCourante(pageCourante);
}
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage)
{
// on met le message d'attente
masquerChargement() ;
// on appelle le modèle
getIModele().changerTaillePage(nouvelleTaillePage) ;
// et on met à jour la taille de page dans les barres d'outils
getGalerieImage().getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
getListeImage().getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
}
 
/**
* Met à jour les barre d'outils avec des nouvelles valeurs
* @param pageMax le nombre de pages
* @param pageEncours la page en cours
* @param taillePage la taille de page
* @param nbElement le nombre d'élements par page
*/
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
{
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
getGalerieImage().getToolBarVue().rafraichir(pages, false) ;
getListeImage().getToolBarVue().rafraichir(pages, false) ;
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getIdVueSelectionnee()) ;
 
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(getIdVueSelectionnee()) ;
if(masked.isMasked())
{
masked.unmask() ;
}
}
 
}
/trunk/src/org/tela_botanica/client/image/ImageModele.java
2,6 → 2,7
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
10,9 → 11,12
import org.tela_botanica.client.modeles.ListeImageCarnet;
import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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;
33,35 → 37,81
*/
public class ImageModele implements Rafraichissable {
/**
* Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)
*/
private static boolean estInstancie = false ;
/**
* Le médiateur associé au modèle
*/
private ImageMediateur iMediateur = null ;
/**
* La liste des image affichées en cours
*/
private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;
/**
* Table de correspondance entre les mots clés et leurs identifiants
*/
private HashMap motsCles = new HashMap(0) ;
/**
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
*/
private Store st = null ;
/**
* Arbre des mots clés
*/
private com.gwtext.client.data.Tree arbreMotsCles = new Tree() ;
/**
* Numéro de page en cours
*/
private int pageEncours = 0 ;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Taille de page (par défaut 50)
*/
private int taillePage = 50 ;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
/**
* Retourne une instance de manière unique
* @param im le médiateur à associer
* @return l'instance du modèle
*/
static ImageModele Instance(ImageMediateur im)
{
// si le modèle n'est pas encore instancié
if(!estInstancie)
{
// on en crée un nouveau
return new ImageModele(im);
}
else
{
// sinon on renvoit null, interdisant explicitement la création d'un autre exemplaire
return null ;
}
}
/**
* Le constructeur est privé et seule la méthode instance y accède
* @param im le médiateur à associé
*/
private ImageModele(ImageMediateur im) {
iMediateur = im ;
}
/**
* Accesseur pour le médiateur
* @return
*/
public ImageMediateur getIMediateur()
{
return iMediateur ;
73,8 → 123,17
*/
public void obtenirPhotoGalerie(Rafraichissable r)
{
// on rassemble les critères
String[][] criteres = {{"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} } ;
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)
NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO() ;
niaDAO.obtenirNombreImages(this, criteres) ;
// ensuite on demande la page correspondante avec les mêmes critères
String[][] criteres2 = { {"ci_limite" ,""+taillePage },{"ci_numero_page",""+pageEncours} } ;
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO();
liaDAO.ObtenirListeImages(this);
liaDAO.ObtenirListeImages(this, criteres2);
}
/**
217,10 → 276,12
String key = ids[i] ;
ImageCarnet ic = (ImageCarnet)cacheImage.get(key) ;
rids[i] = ic.getId() ;
cacheImage.remove(key) ;
}
if(rids.length != 0)
{
{
liDao.supprimerBaseDeDonnees(rids);
}
}
231,11 → 292,13
*/
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement)
{
// si l'on a reçu une liste d'images
if(nouvelleDonnees instanceof ListeImageCarnet)
{
ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ;
Object[][] photoData = new Object[data.size()][7];
int i = 0 ;
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
ImageCarnet im = (ImageCarnet) data.get(it.next());
250,7 → 313,7
i++ ;
}
// creation du store
// creation du store qui les contient
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
269,7 → 332,13
rafraichirListeImage(nouvelleDonnees);
st = photoStore ;
st.load() ;
// par défaut le store est trié sur le numéro d'image
st.sort("num_image") ;
 
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
if(repandreRafraichissement)
{
getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ;
276,14 → 345,18
}
}
// si on reçoit un tableau JSON
if(nouvelleDonnees instanceof JSONArray)
{
// alors on a reçu les informations sur les mots clés
JSONArray reponse = (JSONArray)nouvelleDonnees ;
final int taillemax = reponse.size();
// si le tableau est vide
if(taillemax == 0)
{
// on crée un arbre vide
TreeNode root = new TreeNode() ;
root.setId("racine") ;
root.setText("Tags") ;
293,9 → 366,10
arbreMotsCles.setRootNode(root) ;
}
// pour chacun des élements du tableau
for (int j = 0; j < taillemax ; j++)
{
// on extrait les élements du tableau
if(reponse.get(j).isObject() != null)
{
JSONObject noeud = (JSONObject)reponse.get(j) ;
306,6 → 380,7
String[] usObj = {mot_cle, id_noeud} ;
// et on construit l'arbre à partir de la racine (qui est toujoursl e premier élément)
if(id_noeud.equals("racine"))
{
TreeNode root = new TreeNode() ;
317,6 → 392,8
}
else
{
// et en ajoutant les noeuds un à un (qui sont renvoyé dans l'ordre hierarchique de leur niveau
// ce qui permet de les traiter séquentiellement)
TreeNode node = new TreeNode() ;
node.setId(id_noeud) ;
node.setText(mot_cle) ;
327,10 → 404,26
parentNode.appendChild(node) ;
}
}
}
}
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
rafraichirArbreMotsCles(arbreMotsCles) ;
getIMediateur().getMetadonneesIptcExif().getPanneauMotsCles().rafraichir(arbreMotsCles, true) ;
}
// et on notifie le médiateur de la mise à jour en lui passant une copie des données
getIMediateur().rafraichirArbreMotsCles(arbreMotsCles) ;
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'images correspondant aux critères
if(nouvelleDonnees instanceof int[])
{
int[] pages = (int[])nouvelleDonnees ;
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
pageMax = calculerNbPages(pages[0]) ;
nbElements = pages[0] ;
// et on notifie de le mediateur du changement des valeurs
getIMediateur().changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
}
}
/**
510,4 → 603,64
MCDao.deplacerBaseDeDonnees(motCleModifie) ;
}
/**
* Change le numéro de la page en cours et envoie une demande de mise à jour des données
* @param nouvellePageCourante la nouvelle page à afficher
*/
public void changerNumeroPage(int nouvellePageCourante)
{
pageEncours = nouvellePageCourante ;
obtenirPhotoGalerie(this) ;
}
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
*/
public int calculerNbPages(int nbElements)
{
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return nPageInt.intValue() ;
}
/**
* Recalcule la page en cours lors du changement du nombre d'élements
* @param nbElements le nombre d'élements total
* @return la nouvelle page encours
*/
public int calculerPageCourante(int nbElements)
{
// on calcule le nombre de page
int nouvelNbPages = calculerNbPages(nbElements) ;
// la nouvelle page en cours
double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return nPageInt.intValue() ;
}
/**
* Change la taille de page et recalcule la page encours
* @param nouvelleTaillePage la nouvelle taille de page à utiliser
*/
public void changerTaillePage(int nouvelleTaillePage)
{
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
obtenirPhotoGalerie(this) ;
}
}
/trunk/src/org/tela_botanica/client/vues/ListeImageVue.java
11,6 → 11,9
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.JsObject;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
20,6 → 23,7
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StoreMgr;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.util.JavaScriptObjectHelper;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
69,6 → 73,8
// store qui gère les données de la liste d'images
private Store st = null;
private ColumnConfig cl = null;
private pageToolBarVue bt = null ;
 
public ListeImageVue(ImageMediateur im) {
 
77,12 → 83,15
this.setId("listeImageGrid");
 
this.iMediateur = im;
bt = new pageToolBarVue(im);
this.setBottomToolbar(bt) ;
 
numImage = new ColumnConfig("numéro", "num_image", 100, true);
numImage = new ColumnConfig("numéro", "num_image", 30, true);
datImage = new ColumnConfig("date", "dat_image", 120, true);
lieImage = new ColumnConfig("lieu", "lie_image", 120, true);
appImage = new ColumnConfig("appareil", "app_image", 200, true);
urlImage = new ColumnConfig("Image", "url_image_S", 200, true,
urlImage = new ColumnConfig("Image", "url_image_S", 30, true,
new Renderer() {
 
public String render(Object value,
97,11 → 106,12
 
});
 
ColumnConfig[] cm = { numImage, datImage, lieImage, appImage, urlImage };
ColumnConfig[] cm = {numImage, urlImage, datImage, lieImage, appImage};
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");
118,7 → 128,6
this.setStore(st);
this.getView().setAutoFill(true);
 
// this.setLoadMask(true) ;
this.setLoadMask("chargement");
 
ajouterListeners();
233,6 → 242,7
st = (Store) nouvelleDonnees;
st.load();
this.reconfigure(st, this.getColumnModel());
}
 
if (repandreRafraichissement) {
248,6 → 258,11
getSelectionModel().selectRecords(sel);
}
}
public pageToolBarVue getToolBarVue()
{
return bt ;
}
 
/**
* @param estInstancie
/trunk/src/org/tela_botanica/client/vues/BarreOutilsVue.java
12,6 → 12,13
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.menu.Menu;
 
 
/**
* 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 {
ToolbarMenuButton images = null ;
18,6 → 25,18
ImageMediateur iMediateur = null ;
MenuImageVue imageMenu = null ;
 
/**
* Constructeur sans argument (ne doit pas être utilisé donc privé)
*/
private BarreOutilsVue()
{
super() ;
}
/**
* Constructeur avec paramètres
* @param im
*/
public BarreOutilsVue(ImageMediateur im) {
super() ;
25,7 → 44,7
iMediateur = im ;
imageMenu = new MenuImageVue(im) ;
images = new ToolbarMenuButton("Images",imageMenu) ;
images = new ToolbarMenuButton("Fichiers",imageMenu) ;
this.addButton(images) ;
}
/trunk/src/org/tela_botanica/client/vues/GalerieImageVue.java
1,10 → 1,13
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import com.gwtext.client.core.Ext;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.XTemplate;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
15,90 → 18,131
import com.gwtext.client.util.Format;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.DataView;
import com.gwtext.client.widgets.PagingToolbar;
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.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.DataViewListenerAdapter;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.NumberField;
import com.gwtext.client.widgets.form.event.FieldListenerAdapter;
 
/**
* Galerie d'images miniatures
*
* Avec barre de pagination
* @author aurelien
*/
public class GalerieImageVue extends Panel implements Rafraichissable,
VueListable {
 
// instance du médiateur
/**
* 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 pageToolBarVue pt = null ;
/**
* Booleen indiquant si la galerie est instanciée ou pas
*/
private boolean estInstancie = false ;
 
/**
* Constructeur sans argument, privé car ne doit pas être utilisé
*/
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() {
 
public void onHide(Component component) {
// TODO Auto-generated method stub
 
}
 
public void onRender(Component component) {
// TODO Auto-generated method stub
 
}
 
// pour gagner du temps on n'instancie la vue en elle même que lors du premier affichage (lazy rendering)
public void onShow(Component component) {
 
if (dView == null) {
if (!estInstancie) {
initialiser();
}
}
 
});
// et on ajoute la tool bar
pt = new pageToolBarVue(im) ;
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
public void onClick(DataView source, int index, Element node,
EventObject e) {
 
// on en notifie le médiateur
getIMediateur().clicGalerieImage(index, node, e);
 
}
 
public void onContainerClick(DataView source, EventObject e) {
// TODO: appeler le mediateur
 
}
 
// gestion du clic droit
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
public void onDblClick(DataView source, int index, Element node,
EventObject e) {
 
// TODO: appeler le mediateur
// on notife le mediateur
getIMediateur().clicGalerieImage(index, node, e);
 
}
 
// gestion des actions en fonction de la selection
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");
}
}
106,10 → 150,18
});
}
 
/**
* 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
*/
public String[] getIdSelectionnees() {
Record[] selection = getDView().getSelectedRecords();
int taille = selection.length;
123,16 → 175,37
return id_selection;
}
 
/**
* Accesseur pour le médiateur
* @return le mdéiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur pour le store
* @return le store associée à la vue
*/
public Store getSt() {
return st;
}
/**
* Accesseur pour la toolbar
* @return la toolbar associée à la vue
*/
public pageToolBarVue getToolBarVue()
{
return pt ;
}
 
// instantiation paresseuse
/**
* 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
143,6 → 216,7
"<div class='thumb'><img src='{url_image_M}' title='{num_image}'></div>",
"<span>{nom}</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
176,6 → 250,7
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
dView.setStore(st);
 
this.getDView().setLoadingText("chargement");
 
183,29 → 258,53
ajouterListenersDataView();
 
this.add(dView);
 
// enfin on envoie une demande de données au médiateur
getIMediateur().obtenirPhotoGalerie(this);
// et on déclare le composant comme instancié
estInstancie = true ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si l'objet reçu est un store
if (nouvelleDonnees instanceof Store) {
st = (Store) nouvelleDonnees;
// on le charge
st.load();
// on l'affecte à la vue
dView.setStore(st);
// et on rafrachit la vue
dView.refresh();
}
 
// si le com)posant doit répandre le rafraichissement
if (repandreRafraichissement) {
// il en notifie le médiateur en lui donnant une copie des données
getIMediateur().synchroniserDonneesZoomListeGalerie(
nouvelleDonnees, this);
}
if(!estInstancie)
{
estInstancie = true ;
}
}
 
/**
* 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);
 
}
}
/trunk/src/org/tela_botanica/client/vues/pageToolBarVue.java
New file
0,0 → 1,406
package org.tela_botanica.client.vues;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ImageCarnet;
 
import com.google.gwt.core.client.JavaScriptObject;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Template;
import com.gwtext.client.core.XTemplate;
import com.gwtext.client.data.Record ;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.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.Component;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListener;
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.ComboBoxListener;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.form.event.TextFieldListener;
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
import com.gwtext.client.widgets.menu.Menu;
 
 
/**
* Barre de pagination asynchrone avec filtrage des touches et accès directs et séquentiels à une page
* @author aurelien
*
*/
public class pageToolBarVue extends Toolbar implements Rafraichissable {
/**
* Instance du médiateur à qui on notifie les évnènements
*/
private ImageMediateur iMediateur = 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() ;
/**
* Texte statique de la toolbar 3
*/
private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" images par page ") ;
/**
* Affiche l'intervalle des éléments contenus dans la page
*/
private ToolbarTextItem intervalleElements = new ToolbarTextItem("Images "+pageCourante*taillePage+" sur "+nbElement) ;
 
 
/**
* retourne le mediateur associe à la barre
*/
public ImageMediateur getImediateur()
{
return iMediateur ;
}
/***
* constructeur sans argument (privé car ne doit pas être utilisé)
*/
private pageToolBarVue()
{
super() ;
}
/**
* constructeur avec paramètres
* @param im le médiateur à associer à la barre
*/
public pageToolBarVue(ImageMediateur im)
{
super() ;
iMediateur = im ;
// 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) ;
// le store contient les valeur possibles pour les tailles de page
final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());
store.load();
// 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(store) ;
selecteurTaillePage.setWidth(40) ;
selecteurTaillePage.setEditable(false) ;
addField(selecteurTaillePage) ;
selecteurTaillePage.setValue("50") ;
selecteurTaillePage.setWidth(50) ;
addItem(nbElemParPage) ;
// on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
addFill() ;
addItem(intervalleElements) ;
addSpacer() ;
// on ajoute les différents listeners
ajouterListeners() ;
}
/**
* 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() {
 
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
getImediateur().changerNumeroPage(pageCourante) ;
}
}
}) ;
suivPage.addListener(new ButtonListenerAdapter() {
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
getImediateur().changerNumeroPage(pageCourante) ;
}
}
}) ;
champPage.addListener(new TextFieldListenerAdapter() {
 
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() ;
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) ;
getImediateur().changerNumeroPage(pageCourante) ;
 
}
else
{
// sinon on reaffriche l'ancien numero de page sans rien changer
rafraichirNumeroPage() ;
}
}
}
});
// pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
champPage.addKeyPressListener(new EventCallback() {
 
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() {
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()
{
Integer intPage = new Integer(pageTotale) ;
String st = intPage.toString() ;
champPage.setValue(""+(pageCourante+1)) ;
surTotalPage.setText(" sur "+pageTotale) ;
// 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("Images "+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("Images "+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
*/
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 = pageTotale - 1 ;
// le cas échéant on en notifie le médiateur
getImediateur().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
*/
public String[][] getNbPages()
{
String[][] pages = {{"200"},{"100"},{"50"},{"20"},{"10"}} ;
return pages ;
}
 
/**
* Envoie au médiateur une demande pour modifier la taille de la page
* (qui va à sont 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) {
getImediateur().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) ;
}
}
/trunk/src/org/tela_botanica/client/modeles/NombreImageAsynchroneDAO.java
New file
0,0 → 1,66
package org.tela_botanica.client.modeles;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.HTTPRequest;
import com.google.gwt.user.client.ResponseTextHandler;
import com.google.gwt.user.client.Window;
 
public class NombreImageAsynchroneDAO {
 
private ImageMediateur iMediateur = null ;
public void setImediateur(ImageMediateur im)
{
iMediateur = im ;
}
public void obtenirNombreImages(final Rafraichissable r, String[][] criteres)
{
String requete = "" ;
if(criteres != null)
{
for (int i = 0; i < criteres.length; i++) {
if(!criteres[i][0].equals("ci_ordre"))
{
if(i != 0)
{
requete += "&" ;
}
requete += criteres[i][0]+"="+criteres[i][1] ;
if(i != criteres.length - 1)
{
requete += "&" ;
}
}
}
}
HTTPRequest.asyncGet("jrest/InventoryImageCount/0/"+requete, new ResponseTextHandler() {
public void onCompletion(String responseText) {
final JSONValue responseValue = JSONParser.parse(responseText);
if(responseValue.isArray() != null)
{
JSONValue res = responseValue.isArray().get(0) ;
JSONString reponseNombre = res.isString() ;
int maxImages = (int)Integer.parseInt(reponseNombre.stringValue()) ;
int[] nbImages = {maxImages} ;
r.rafraichir(nbImages, true) ;
}
}
}) ;
}
}
/trunk/src/org/tela_botanica/client/modeles/ImageUploaderAsynchroneDAO.java
58,9 → 58,9
private static void appelerUploadMultiple()
{
final Window nPan = new Window("Upload multiple");
nPan.setSize(640, 800);
nPan.setWidth(640) ;
 
final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" archive=\"wjhk.jupload.jar\" alt=\"\" mayscript=\"\" height=\"770\" width=\"625\">";
final String applet = "<applet code=\"wjhk.jupload2.JUploadApplet\" archive=\"wjhk.jupload.jar\" alt=\"\" mayscript=\"\" height=\"350\" width=\"625\">";
final String paramPostTarget = "<param name=\"postURL\" value=\"jrest/InventoryImage/\">";
final String paramUploadPolicy = "<param name=\"uploadPolicy\" value=\"PictureUploadPolicy\">";
final String paramMaxChunkSize = "<param name=\"maxChunkSize\" value=\"0\">";
/trunk/src/org/tela_botanica/client/modeles/ListeImageAsynchroneDAO.java
35,9 → 35,24
iMediateur = im ;
}
public void ObtenirListeImages(final Rafraichissable r)
public void ObtenirListeImages(final Rafraichissable r, String[][] criteres)
{
HTTPRequest.asyncGet("jrest/inventoryImageList/1/ci_publiable_eflore=0", new ResponseTextHandler() {
String requete = "" ;
if(criteres != null)
{
for (int i = 0; i < criteres.length; i++) {
requete += criteres[i][0]+"="+criteres[i][1] ;
if(i != criteres.length - 1)
{
requete += "&" ;
}
}
}
HTTPRequest.asyncGet("jrest/InventoryImageList/0/"+requete, new ResponseTextHandler() {
public void onCompletion(String responseText) {
final ListeImageCarnet photoData ;