Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 185 → Rev 195

/trunk/src/org/tela_botanica/client/vues/ZoomImageVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ImageGeneriqueVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/PanneauFiltresImagesVues.java
File deleted
/trunk/src/org/tela_botanica/client/vues/AutoCompleteAsyncTextBox.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/LocationAssistantVue.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/MiniZoomImageVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MiniListeObservationVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/PanneauFiltresObservationVues.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesObsFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/FormulaireSaisieObservationVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MenuObservationVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MenuIdVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/SaisieMotsClesVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ArbreEntiteGeographiqueObservationFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/BarreOutilsVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/SelectionFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MotsClesObsVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/InformationRepartitionVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MenuImageVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/BarreNotationVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/NuageMotsClesVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesObsVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MenuFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/BarreRechercheFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ArbreDateObservationFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/GalerieImageVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/MenuLiaisonVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ListeImageVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/DateFiltreVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/PanneauMetadonneesVue.java
2,6 → 2,8
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.vues.image.BarreNotationVue;
import org.tela_botanica.client.vues.image.MiniListeObservationVue;
 
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Label;
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
5,8 → 5,6
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
14,19 → 12,13
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListener;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.ContainerListener;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListener;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
 
/**
/trunk/src/org/tela_botanica/client/vues/observation/ArbreDateObservationFiltreVue.java
New file
0,0 → 1,646
package org.tela_botanica.client.vues.observation;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.DateObservation;
import org.tela_botanica.client.modeles.ListeDateObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.core.client.GWT;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
import com.gwtext.client.core.EventObject;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
/**
* Les localites en cours
*/
private String donneesDateEnCours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreDonneesDates = null;
 
/**
* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
*/
private Tree donneesDates = new Tree();
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
private boolean arbreCharge = false ;
 
private String nomFiltre = "" ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreDateObservationFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreDateObservationFiltreVue(ObservationMediateur obs) {
 
// on crée le panel
super("Dates");
this.observationMediateur = obs;
 
arbreDonneesDates = new TreePanel();
 
this.setPaddings(5);
 
this.setCollapsible(true);
this.setAutoWidth(true);
if (GWT.isScript()) {
setAutoScroll(true);
}
 
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
public void onRender(Component component) {
 
// on interdit le drag and drop dans l'arbre
arbreDonneesDates.setEnableDD(false);
arbreDonneesDates.setId("x-view-tree-filter-date");
arbreDonneesDates.setAutoWidth(false);
arbreDonneesDates.setBorder(false);
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Dates");
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", "racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.setRootVisible(true);
arbreDonneesDates.setBorder(false);
root.setExpandable(true) ;
 
add(arbreDonneesDates);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
// enfin on considère le composant comme instancié
estInstancie = true;
 
}
 
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des entites
*/
private void ajouterListeners() {
arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
public void onClick(TreeNode node, EventObject e) {
nomFiltre = "" ;
donneesDateEnCours = "" ;
String nomPere = "" ;
String nomGrandPere = "" ;
switch(node.getDepth())
{
case 0:
if(!arbreCharge)
{
/* arbreCharge = true ;
observationMediateur.obtenirDatesObservation() ;*/
arbreDonneesDates.getRootNode().expand();
}
else
{
observationMediateur.obtenirNombreObservation() ;
}
return ;
case 3: nomFiltre += "annee,mois,jour";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 2: nomFiltre += "annee,mois";
nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
break;
case 1: nomFiltre += "annee";
donneesDateEnCours += ((String[])node.getUserObject())[1] ;
break;
default:
break;
}
filtreModifie = true ;
observationMediateur.obtenirNombreObservation() ;
}
}) ;
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
}
public void initialiser() {
arbreCharge = false ;
arbreDonneesDates.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if (nouvelleDonnees instanceof ListeDateObservation) {
String annee=null;
String mois=null;
String jour=null;
ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ;
// on crée un arbre vide
TreeNode root = new TreeNode();
root.setId("racine_date");
root.setText("Dates");
String[] usObjRoot = { "Dates", "Dates", "racine_date"};
root.setUserObject(usObjRoot);
Tree nouvelArbre = new Tree();
nouvelArbre.setRootNode(root);
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
DateObservation ent=(DateObservation) data.get(it.next());
annee= ent.getAnnee() ;
mois= ent.getMois() ;
String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
jour= ent.getJour() ;
if(annee.contains("0000")) {
annee="Inconnue" ;
}
if(jour.contains("00")) {
jour="Inconnue" ;
}
Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee);
// si la région existe déjà
if(noeudMemeAnnee != null)
{
// on teste si la localité existe
Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois));
if(noeudMemeMois != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour));
if(noeudMemeJour != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
noeudMemeMois.appendChild(node_jour) ;
String[] usObj = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj);
}
}
else
{
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
noeudMemeAnnee.appendChild(node_mois) ;
String[] usObj = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj);
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj2 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj2);
}
}
else
{
TreeNode node_annee = new TreeNode();
node_annee.setId(""+annee);
node_annee.setText(annee);
root.appendChild(node_annee) ;
String[] usObj = {annee, annee, annee};
node_annee.setUserObject(usObj);
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
node_annee.appendChild(node_mois) ;
String[] usObj2 = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj2);
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
node_mois.appendChild(node_jour) ;
String[] usObj3 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj3);
}
 
}
// on trie
root.sort(comparerNoeuds()) ;
// on vide tous les noeuds
arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
public boolean execute(Node node) {
node.remove();
return true;
}
});
 
// et on recopie le nouvel arbre
copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates
.getRootNode());
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
// l'état du filtre est réinitialisé
filtreModifie = false;
//show() ;
doLayout();
 
}
if(nouvelleDonnees instanceof Observation)
{
// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
// de l'arbre
if(!arbreCharge) {
return;
}
Observation ent = (Observation)nouvelleDonnees ;
String dateSpl[] = ent.getDate().split("/") ;
String annee= dateSpl[2];
String mois= dateSpl[1];
String jour= dateSpl[0];
String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
Node root = arbreDonneesDates.getRootNode() ;
if(annee.contains("0000") || annee.equals(null)) {
annee="Inconnue" ;
}
if(jour.contains("00") || jour.equals(null)) {
jour="Inconnue" ;
}
Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee);
// si la région existe déjà
if(noeudMemeAnnee != null)
{
// on teste si la localité existe
Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois));
if(noeudMemeMois != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour));
if(noeudMemeJour != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj);
noeudMemeMois.appendChild(node_jour) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
String[] usObj = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj);
noeudMemeAnnee.appendChild(node_mois) ;
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj2 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj2);
node_mois.appendChild(node_jour) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
TreeNode node_annee = new TreeNode();
node_annee.setId(""+annee);
node_annee.setText(annee);
String[] usObj = {annee,annee,annee};
node_annee.setUserObject(usObj);
root.appendChild(node_annee) ;
TreeNode node_mois = new TreeNode();
node_mois.setId(""+(annee+mois));
node_mois.setText(moisLettre);
String[] usObj2 = {moisLettre,mois,annee+mois};
node_mois.setUserObject(usObj2);
node_annee.appendChild(node_mois) ;
TreeNode node_jour = new TreeNode();
node_jour.setId(""+(annee+mois+jour));
node_jour.setText(jour);
String[] usObj3 = {jour,jour,annee+mois+jour};
node_jour.setUserObject(usObj3);
node_mois.appendChild(node_jour) ;
// TODO : améliorer la compararaison des noeuds
root.sort(comparerNoeuds()) ;
}
arbreDonneesDates.doLayout() ;
}
}
 
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreDonneesDates;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
public String renvoyerNomFiltre() {
 
return "Dates";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
public String[] renvoyerValeursAFiltrer() {
 
valider();
String valeursFiltrees[] = {nomFiltre, donneesDateEnCours } ;
 
return valeursFiltrees;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setUserObject(usObj);
child.setId(""+usObj[2]);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
public void valider() {
if (estInstancie) {
}
}
public Comparator<TreeNode> comparerNoeuds()
{
return new Comparator<TreeNode>() {
 
public int compare(TreeNode o1, TreeNode o2) {
String n1 = ((String[])o1.getUserObject())[1] ;
String n2 = ((String[])o2.getUserObject())[1] ;
return n1.compareTo(n2) ;
}
} ;
}
public String renvoyerMois(int numMois) {
switch (numMois) {
case 1:
return "janvier" ;
case 2:
return "fevrier" ;
case 3:
return "mars" ;
case 4:
return "avril" ;
case 5:
return "mai" ;
case 6:
return "juin" ;
case 7:
return "juillet" ;
case 8:
return "août" ;
case 9:
return "septembre" ;
case 10:
return "octobre" ;
case 11:
return "novembre" ;
case 12:
return "décembre" ;
default:
return "Inconnue" ;
}
}
 
public void raz() {
arbreCharge = false ;
arbreDonneesDates.collapseAll();
arbreDonneesDates.clear();
 
TreeNode root = new TreeNode("Dates");
root.setId("racine_date");
String[] usObject = { "Dates", "Dates", "racine_date" };
root.setUserObject(usObject);
 
arbreDonneesDates.setRootNode(root);
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
this.doLayout() ;
}
 
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java
New file
0,0 → 1,765
package org.tela_botanica.client.vues.observation;
 
 
import java.util.Iterator;
 
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.vues.BarrePaginationVue;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Tool;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter;
 
/**
* Liste d'observation composée de ligne d'observation
* l'interface rafraichissable et l'interface vueListable
*
* @author David Delon 2008
*/
public class ListeObservationVue extends GridPanel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
 
/**
* Config de colonne
*/
private ColumnConfig etatObservation;
/**
* Config de colonne
*/
private ColumnConfig nomSaisiObservation;
/**
* Config de colonne
*/
private ColumnConfig nomRetenuObservation;
/**
* Config de colonne
*/
private ColumnConfig lieuObservation;
/**
* Config de colonne
*/
private ColumnConfig dateObservation;
/**
* Config de colonne
*/
private ColumnConfig ordreObservation;
/**
* Modele de colonnes
*/
private ColumnModel modeleColonnes;
 
/**
* Store qui contient les données à afficher
*/
private Store st = null;
/**
* Barre de pagination
*/
private BarrePaginationVue bt = null ;
 
/**
* Numéro de page en cours
*/
private int pageEncours = 0 ;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Taille de page (par défaut 20)
*/
private int taillePage = 20 ;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
private ListeObservation cacheListeObservation = null;
private Tool exporterObservations = null ;
private final int KEY_ENTER = 13;
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ListeObservationVue()
{
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur à associer
*/
public ListeObservationVue(ObservationMediateur obs) {
this.observationMediateur = obs;
setHeader(true);
// on place la barre de pagination
bt = new BarrePaginationVue(this);
bt.setLabelElement("Observations");
bt.setTaillePageParDefaut(20);
bt.setIntervallesPages(new String[] {"400","200", "100" , "50" , "20", "10"}) ;
Toolbar barreActions = new Toolbar();
ToolbarButton publier = new ToolbarButton("Rendre publiques");
publier.addListener(new ButtonListenerAdapter() {
public void onClick(Button b, EventObject e) {
observationMediateur.transmettreObservations(true);
}
});
ToolbarButton privatiser = new ToolbarButton("Rendre privées");
privatiser.addListener(new ButtonListenerAdapter() {
public void onClick(Button b, EventObject e) {
observationMediateur.transmettreObservations(false);
}
});
ToolbarButton supprimer = new ToolbarButton("Supprimer");
supprimer.addListener(new ButtonListenerAdapter() {
public void onClick(Button b, EventObject e) {
observationMediateur.supprimerObservations();
}
});
 
ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>");
barreActions.addButton(publier);
barreActions.addButton(privatiser);
barreActions.addSpacer();
barreActions.addButton(supprimer);
barreActions.addSpacer();
barreActions.addItem(exporter);
this.setTopToolbar(barreActions) ;
this.setBottomToolbar(bt);
this.setCollapsible(true);
this.setTitleCollapse(true);
 
this.setTitle("Observations") ;
 
// 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() ;
}
} ;
etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, 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 "" ;
}
}
});
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200, true, colRend);
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200, true, colRend);
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200, true, colRend);
dateObservation = new ColumnConfig("Date", "date_observation", 120, true, dateRend);
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50, true, colRend);
// on associe le modèle de colonnes
ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation};
modeleColonnes = new ColumnModel(cm);
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
this.setEnableColumnResize(true);
//temp dd viewport desactive ajout de ces 2 lignes
// this.setAutoWidth(true);
// temp
// creation du store
 
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation };
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
this.setStore(st);
this.getView().setAutoFill(true);
this.getView().setForceFit(true) ;
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("Chargement");
// on ajoute les listeners
ajouterListeners();
}
 
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
this.addGridRowListener(new GridRowListenerAdapter() {
// gestion du clic sur une ligne
public void onRowClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur et on lui passe le nuémro de ligne
Record rd = getSelectionModel().getSelected();
String ordreObservation = rd.getAsString("ordre_observation") ;
observationMediateur.onClicListeObservation(rowIndex,ordreObservation);
}
 
// gestion du clic droit
public void onRowContextMenu(GridPanel grid, int rowIndex,
EventObject e) {
// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
e.stopEvent() ;
// on notifie le médiateur en lui passant l'évenement
observationMediateur.montrerContextMenu(e);
}
 
// gestion du double clic
public void onRowDblClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur en lui passant le numéro de ligne
observationMediateur.doubleClicListeObservation(rowIndex);
}
});
this.addGridListener(new GridListenerAdapter() {
public void onKeyPress(EventObject e) {
if(e.getKey() == KEY_ENTER) {
Record rd = getSelectionModel().getSelected();
int rowIndex = st.indexOf(rd);
String ordreObservation = rd.getAsString("ordre_observation") ;
observationMediateur.onClicListeObservation(rowIndex, ordreObservation);
}
}
});
this.addListener(new PanelListenerAdapter() {
public void onRender(Component c) {
ExtElement lienExport = Ext.get("lienExport") ;
lienExport.addListener("click", new EventCallback() {
 
public void execute(EventObject e) {
observationMediateur.exporterObservations();
}
});
}
});
}
 
/**
* Méthode héritée de l'interface VueListable
* Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres
*/
public String[] getIdSelectionnees() {
Record[] selection = this.getSelectionModel().getSelections();
int taille = selection.length;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("ordre_observation");
}
 
return id_selection;
}
 
/**
* Sélectionne des enregistrements donné
* @param sel un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
getSelectionModel().clearSelections();
getSelectionModel().selectRecords(sel);
}
/**
* Accesseur pour la toolbar de pagination
* @return la toolbar de pagination
*/
public BarrePaginationVue getToolBarVue()
{
return bt ;
}
 
 
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
 
if (masked!=null) {
masked.mask("Chargement") ;
}
 
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
if(masked.isMasked())
{
masked.unmask() ;
}
}
}
 
 
/**
* Méthode héritée de l'interface rafraichissable
* @param nouvelleDonnees les nouvelles données
* @param repandreRafraichissement le booleen de notification du rafraichissement
*/
 
 
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
// si l'on a reçu une liste d'observation
if(nouvelleDonnees instanceof ListeObservation)
{
ListeObservation data = (ListeObservation) nouvelleDonnees ;
Object[][] observationData = new Object[data.size()][7];
int i = 0 ;
if(data.size() == 0)
{
pageEncours = 0 ;
}
// on la parse et on récupère les informations qui nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=(Observation) data.get(it.next());
observationData[i][0]= obs.getTransmis();
observationData[i][1]= obs.getNomSaisi();
observationData[i][2]= obs.getNomRetenu();
String lieu=obs.getLieudit();
if(lieu.contains("000null") || lieu.equals(null) || (lieu.trim()).equals("")) {
observationData[i][3]= obs.getLocalite();
}
else {
observationData[i][3]= obs.getLocalite()+", "+obs.getLieudit();
}
observationData[i][4]= obs.getDate();
observationData[i][5]= obs.getNumeroOrdre();
observationData[i][6]= obs.getNumeroNomenclaturalSaisi();
i++ ;
}
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
// Non affiches :
FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
// on associe le store
 
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(observationData);
final ArrayReader reader = new ArrayReader(rd);
final Store observationStore = new Store(dataProxy, reader);
st = observationStore ;
st.load() ;
// et on reconfigure et rafraichit la vue
this.reconfigure(st, this.getColumnModel());
demasquerChargement();
cacheListeObservation=data;
observationMediateur.onRafraichissementListeObservations();
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
if(nouvelleDonnees instanceof int[])
{
int[] pages = (int[])nouvelleDonnees ;
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
pageMax = calculerNbPages(pages[0]) ;
nbElements = pages[0] ;
// et on notifie de le mediateur du changement des valeurs
changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
masquerChargement();
observationMediateur.obtenirListeObservation(this);
}
// si l'on a reçu une Observation
if(nouvelleDonnees instanceof Observation) {
Observation obs= (Observation) nouvelleDonnees;
if (obs.getNumeroOrdre()==null) { // Nouvelle observation
// On affiche la dernière page
pageEncours = pageMax ;
masquerChargement();
 
observationMediateur.obtenirNombreObservation();
}
else { // Modification d'une observation
masquerChargement();
 
observationMediateur.obtenirNombreObservation();
}
}
// Si on a effectué une suppression
if(nouvelleDonnees instanceof String)
{
String str = (String)nouvelleDonnees ;
observationMediateur.obtenirNombreObservation() ;
}
}
// GESTION DE LA PAGINATION
 
public ListeObservation getCacheListeObservation() {
return cacheListeObservation;
}
 
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
*/
public int calculerNbPages(int nbElements)
{
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) 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()) ;
}
 
/**
* 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) {
pageEncours = pageCourante ;
masquerChargement();
 
// On lance le chargerment des observations
observationMediateur.obtenirNombreObservation();
getToolBarVue().changerPageCourante(pageCourante);
}
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage)
{
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
 
masquerChargement();
 
// On lance le chargement des observations
observationMediateur.obtenirNombreObservation();
// et on met à jour la taille de page dans les barres d'outils
getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
}
 
/**
* Met à jour les barre d'outils avec des nouvelles valeurs
* @param pageMax le nombre de pages
* @param pageEncours la page en cours
* @param taillePage la taille de page
* @param nbElement le nombre d'élements par page
*/
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
{
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
getToolBarVue().rafraichir(pages, false) ;
}
/**
* Renvoie la taille de page en cours d'utilisation
* @return la taille de page
*/
public int getTaillePage() {
return taillePage;
}
/**
* Renvoie le numéro de la page encours (attention on commence à 0)
* @return le numéro de la page en cours
*/
public int getPageEncours() {
return pageEncours;
}
public void afficherFiltres(String nLieu, String nDate)
{
String titre = "Observations " ;
if(!nLieu.equals(""))
{
titre += " - Lieu : "+nLieu ;
}
if(!nDate .equals(""))
{
titre += " - Date : "+nDate ;
}
this.setTitle(titre) ;
}
 
public void raz() {
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
// Non affiches :
FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation };
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
this.setStore(st);
}
public boolean verifierFormatDate(String date) {
String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;
if(date.matches(regex) && !date.equals("0000-00-00")) {
return true ;
}
else {
return false;
}
}
 
}
Property changes:
Added: svn:executable
+*
\ No newline at end of property
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java
New file
0,0 → 1,183
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.form.TextField;
 
public class MotsClesObsVue extends Panel implements Filtrable, Rafraichissable {
private ObservationMediateur oMediateur = null ;
/**
* Barre de recherche
*
*/
private TextField champRecherche = null;
 
/**
* Booleen d'etat du filtre
*/
private boolean filtreModifie = false;
 
/**
* mot(s) à chercher
*/
private String motsAChercher = "";
/**
* bouton de validation
*/
private Button ok = null ;
private Button afficherNuage = null;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private MotsClesObsVue() {
super();
}
 
/**
* Constructeur avec médiateur
*
* @param im
*/
public MotsClesObsVue(ObservationMediateur om) {
super();
oMediateur = om;
 
Label labelRecherche = new Label("Mots clés :");
champRecherche = new TextField();
ok = new Button("Rechercher");
afficherNuage = new Button("Voir les mots clés");
 
add(labelRecherche);
add(champRecherche);
add(ok);
add(afficherNuage);
 
setPaddings(5);
setBorder(false);
setAutoWidth(true);
setCollapsible(true);
 
ajouterListeners();
}
 
/**
* ajoute des listeners
*/
private void ajouterListeners() {
 
// gestion de la touche entrée
champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() {
 
public void onKey(int key, EventObject e) {
 
valider();
}
 
});
ok.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
valider();
}
});
afficherNuage.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
// oMediateur.afficherNuageMotsCles();
}
});
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
if(nouvelleDonnees instanceof String) {
champRecherche.setValue(champRecherche.getValueAsString()+" "+(String)nouvelleDonnees);
}
filtreModifie = false;
 
}
 
/**
* renvoie l'état du filtre (modifié ou non)
*
* @return l'état du filtre
*/
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
/**
* Renvoie le nom du filtre
*
* @return le nom du filtre
*/
public String renvoyerNomFiltre() {
 
return "Recherche Mots clés";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
public String[] renvoyerValeursAFiltrer() {
 
String[] valeurFiltre = new String[0];
if(!motsAChercher.equals("")) {
valeurFiltre = new String[2];
valeurFiltre[0] = "mots_cles";
valeurFiltre[1] = motsAChercher;
}
return valeurFiltre;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ObservationMediateur getIMediateur() {
return oMediateur;
}
 
/**
* Effectue quelque opérations dans la classe et envoie une requête de
* données au médiateur
*/
public void valider() {
filtreModifie = true;
motsAChercher = champRecherche.getText();
oMediateur.obtenirNombreObservation();
}
 
/**
* Affiche la fenetre
*/
public void afficherFiltre() {
 
champRecherche.setValue(motsAChercher);
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java
New file
0,0 → 1,925
package org.tela_botanica.client.vues.observation;
 
 
 
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ListeReferentielCommune;
import org.tela_botanica.client.modeles.ListeReferentielNom;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.modeles.ReferentielCommune;
import org.tela_botanica.client.modeles.ReferentielNom;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.ListenerConfig;
import com.gwtext.client.core.Position;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.event.BoxComponentListenerAdapter;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.DateField;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.TextArea;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.layout.ColumnLayout;
import com.gwtext.client.widgets.layout.ColumnLayoutData;
import com.gwtext.client.widgets.layout.FormLayout;
import com.gwtext.client.data.Record;
 
/**
* Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il implémente l'interface rafraichissable
* @author aurelien
*
*/
public class FormulaireSaisieObservationVue extends Panel implements Rafraichissable {
 
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
private DateField date = null;
private TextField lieudit = null;
private TextField station = null;
private TextField milieu = null;
private TextField comment = null;
private ComboBox commune = null;
private String departement = null;
private ComboBox espece = null;
private String numeroNom = null;
private String numeroOrdre = null;
 
// Pour remise a zero partielle lors d'une validation
private enum Champs {
DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT
};
 
private String formatDate = null ;
private Button boutonOK = new Button("Créer");
private Button boutonAnnuler = new Button("Réinitialiser");
 
private boolean selectionCommune=false;
private boolean selectionEspece=false;
private boolean modification = false ;
private Toolbar bt = null ;
private final int KEY_ALT = 18;
private final int KEY_BACKSPACE = 8;
private final int KEY_CTRL = 17;
private final int KEY_DELETE = 46;
private final int KEY_DOWN = 40;
private final int KEY_END = 35;
private final int KEY_ENTER = 13;
private final int KEY_ESCAPE = 27;
private final int KEY_HOME = 36;
private final int KEY_LEFT = 37;
private final int KEY_PAGEDOWN = 34;
private final int KEY_PAGEUP = 33;
private final int KEY_RIGHT = 39;
private final int KEY_SHIFT = 16;
private final int KEY_TAB = 9;
private final int KEY_UP = 38;
private int tailleChamps = 350 ;
/**
* Combobox permettant de selectionner le mode
* modification ou bien création
*/
private ComboBox selecteurMode = new ComboBox();
Store storeMode = null ;
 
/**
* Booleen d'instanciation
*/
boolean estInstancie = false ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private FormulaireSaisieObservationVue()
{
super() ;
}
/**
* Constructeur avec argument
* @param im
*/
public FormulaireSaisieObservationVue(ObservationMediateur obs)
{
// on associe le médiateur
observationMediateur = obs ;
setHeader(true);
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
panneauFormulaire.setBorder(false);
// Panneau intermediaire qui contient deux colonnes de formulaire
Panel panneauIntermediaire = new Panel();
panneauIntermediaire.setLayout(new ColumnLayout());
panneauIntermediaire.setBorder(false);
//create first panel and add fields to it
Panel panneauPremierColonne = new Panel();
panneauPremierColonne.setLayout(new FormLayout());
panneauPremierColonne.setBorder(false);
 
//create second panel and add fields to it
Panel panneauSecondeColonne = new Panel();
panneauSecondeColonne.setLayout(new FormLayout());
panneauSecondeColonne.setBorder(false);
this.setPaddings(5) ;
// Accesskey pour debugging
commune=new ComboBox("Commune","commune\" accesskey=\"1",tailleChamps );
final String resultTplCommune = "<div class=\"search-item-commune\">{commune}</div>";
commune.setTpl(resultTplCommune);
commune.setMode(ComboBox.REMOTE);
// commune.setPageSize(10); // Ne fonctionne pas
commune.setItemSelector("div.search-item-commune");
commune.setTypeAhead(true);
commune.setLoadingText("Recherche...");
commune.setHideTrigger(true);
commune.setTabIndex(1);
panneauPremierColonne.add(commune);
 
station = new TextField("Station", "station", tailleChamps);
station.setAllowBlank(true);
station.setTabIndex(3);
panneauPremierColonne.add(station);
date = new DateField("Date", "date", 100);
date.setAllowBlank(true);
formatDate = "d/m/Y";
date.setFormat(formatDate) ;
date.setTabIndex(5);
panneauPremierColonne.add(date);
 
espece=new ComboBox("Espèce","nom",tailleChamps );
final String resultTplEspece = "<div class=\"search-item-espece\">{nom}</div>";
 
espece.setTpl(resultTplEspece);
espece.setMode(ComboBox.REMOTE);
// commune.setPageSize(10); // Ne fonctionne pas
espece.setItemSelector("div.search-item-espece");
espece.setTypeAhead(true);
espece.setLoadingText("Recherche...");
espece.setHideTrigger(true);
espece.setTabIndex(6);
 
panneauPremierColonne.add(espece);
lieudit = new TextField("Lieu-dit", "lieudit", tailleChamps);
lieudit.setAllowBlank(true);
lieudit.setTabIndex(2);
panneauSecondeColonne.add(lieudit);
milieu = new TextField("Milieu", "milieu", tailleChamps);
milieu.setAllowBlank(true);
milieu.setTabIndex(4);
panneauSecondeColonne.add(milieu);
comment = new TextArea("Notes", "comment");
comment.setAllowBlank(true);
comment.setHeight(50);
comment.setWidth(tailleChamps);
comment.setTabIndex(7);
panneauSecondeColonne.add(comment);
panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5));
panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5));
panneauFormulaire.add(panneauIntermediaire);
Object[][] mode = {{"création",false} , {"modification", true} };
storeMode = new SimpleStore(new String[] { "nom_mode", "mode" },
mode);
storeMode.load();
selecteurMode.setStore(storeMode);
selecteurMode.setDisplayField("nom_mode") ;
selecteurMode.setLabel("mode ") ;
selecteurMode.setForceSelection(true) ;
selecteurMode.setValue("création") ;
selecteurMode.setEditable(false) ;
selecteurMode.setCls("x-selec-crea") ;
bt = new Toolbar() ;
bt.addSpacer() ;
bt.addText("Mode de saisie ") ;
bt.addField(selecteurMode) ;
boutonOK.setTabIndex(8);
boutonAnnuler.setTabIndex(9);
panneauFormulaire.addButton(boutonOK);
panneauFormulaire.addButton(boutonAnnuler);
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")) ;
}
 
});
this.add(panneauFormulaire) ;
this.setTopToolbar(bt) ;
this.setAutoScroll(true);
//this.setAutoHeight(true);
// on ajoute les listeners
ajouterListeners() ;
}
private void ajouterListeners()
{
// Listener completion communne
commune.addListener(new ComboBoxListenerAdapter() {
public void onSelect(ComboBox comboBox, Record record, int index) {
commune.setValue(record.getAsString("commune"));
departement=record.getAsString("departement");
selectionCommune=true;
}
});
ListenerConfig listenerConfigCommune=new ListenerConfig();
listenerConfigCommune.setDelay(10);
listenerConfigCommune.setStopPropagation(false);
listenerConfigCommune.setStopEvent(false);
commune.addKeyPressListener(new EventCallback() {
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if (selectionCommune) {
selectionCommune=false;
}
else {
validerSaisie(Champs.COMMUNE);
// lancer mise a jour
}
break;
default:
departement="";
obtenirListeReferentielCommune();
break;
}
}
}, listenerConfigCommune
);
date.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// TODO Auto-generated method stub
switch(e.getKey()) {
case KEY_ENTER:
validerSaisie(Champs.DATE);
break;
default:
}
}
});
station.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// TODO Auto-generated method stub
switch(e.getKey()) {
case KEY_ENTER:
validerSaisie(Champs.STATION);
break;
default:
}
}
});
// Listener completion espece
espece.addListener(new ComboBoxListenerAdapter() {
public void onSelect(ComboBox comboBox, Record record, int index) {
espece.setValue(record.getAsString("nom"));
numeroNom=record.getAsString("numeroNom");
selectionEspece=true;
observationMediateur.obtenirImageInformationExternes(numeroNom);
}
});
 
ListenerConfig listenerConfigEspece=new ListenerConfig();
listenerConfigEspece.setDelay(10);
listenerConfigEspece.setStopPropagation(false);
listenerConfigEspece.setStopEvent(false);
 
espece.addKeyPressListener(new EventCallback() {
public void execute(EventObject e) {
switch(e.getKey()) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
case KEY_ENTER:
if(selectionEspece) {
selectionEspece=false;
}
else {
validerSaisie(Champs.ESPECE);
}
break;
default:
numeroNom="";
obtenirListeReferentielNom();
break;
}
 
}
}, listenerConfigEspece
);
lieudit.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// TODO Auto-generated method stub
switch(e.getKey()) {
case KEY_ENTER:
validerSaisie(Champs.LIEUDIT);
break;
default:
}
}
});
milieu.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// TODO Auto-generated method stub
switch(e.getKey()) {
case KEY_ENTER:
validerSaisie(Champs.MILIEU);
break;
default:
}
}
});
/*comment.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// TODO Auto-generated method stub
switch(e.getKey()) {
case KEY_ENTER:
validerSaisie(Champs.COMMENT);
break;
default:
}
}
});*/
 
 
boutonOK.addListener(new ButtonListenerAdapter() {
public void onClick(Button button, EventObject e) {
if(modification) {
modifierObservation() ;
}
else {
ajouterObservation();
}
}
});
boutonAnnuler.addListener(new ButtonListenerAdapter() {
public void onClick(Button button, EventObject e) {
if(modification)
{
supprimerObservation() ;
}
else
{
raz();
}
}
});
this.addListener(new ContainerListenerAdapter() {
public void onAfterLayout(Container self) {
ajusterTailleChamps();
commune.focus();
}
});
this.addListener(new BoxComponentListenerAdapter() {
public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) {
ajusterTailleChamps();
}
});
}
/**
* Validation de la saisie
*/
private void validerSaisie(Champs champs) {
if(modification) {
modifierObservation() ;
}
else {
ajouterObservation();
raz(champs);
}
}
/**
* Desactive visuellement ce panneau
*/
public void desactiverPanneau()
{
this.setDisabled(true) ;
}
/**
* Active visuellement ce panneau
*/
public void activerPanneau()
{
this.setDisabled(false) ;
}
 
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) {
// si l'on a reçu une liste du referentiel commune (completion referentiel commune)
if(nouvelleDonnees instanceof ListeReferentielCommune)
{
ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ;
Object[][] communeData = new Object[data.size()][2];
int i = 0 ;
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
ReferentielCommune ref=(ReferentielCommune) data.get(it.next());
communeData[i][0]= ref.getCommune();
communeData[i][1]= ref.getDepartement();
i++ ;
}
// creation du store
FieldDef defCommune = new StringFieldDef("commune");
FieldDef defDepartement = new StringFieldDef("departement");
FieldDef[] defTab = { defCommune, defDepartement};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(communeData);
final ArrayReader reader = new ArrayReader(rd);
Store store=new Store(dataProxy,reader);
store.load() ;
commune.setStore(store);
}
// si l'on a reçu une liste du référentiel nom (complétion referentiel nom)
if(nouvelleDonnees instanceof ListeReferentielNom)
{
ListeReferentielNom data = (ListeReferentielNom) nouvelleDonnees ;
Object[][] nomData = new Object[data.size()][2];
int i = 0 ;
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
ReferentielNom ref=(ReferentielNom) data.get(it.next());
nomData[i][0]= ref.getNom();
nomData[i][1]= ref.getNumeroNom();
i++ ;
}
// creation du store
FieldDef defNom = new StringFieldDef("nom");
FieldDef defNumeroNom = new StringFieldDef("numeroNom");
FieldDef[] defTab = { defNom, defNumeroNom};
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(nomData);
final ArrayReader reader = new ArrayReader(rd);
Store store=new Store(dataProxy,reader);
store.load() ;
espece.setStore(store);
}
// On recoit une observation dont on veut afficher le detail
if(nouvelleDonnees instanceof Observation)
{
Observation obs = (Observation)nouvelleDonnees ;
afficherDetailsObservation(obs) ;
}
// Sur Mise à jour ou suppression d'une suppression ?
if(nouvelleDonnees instanceof String)
{
String str = (String)nouvelleDonnees ;
observationMediateur.obtenirNombreObservation() ;
}
if(nouvelleDonnees instanceof String[]) {
String[] anumNom = (String[])nouvelleDonnees ;
numeroNom = anumNom[1];
espece.setValue(anumNom[0]);
setModification("false");
}
 
}
 
public void obtenirListeReferentielCommune() {
String com=commune.getText().replaceAll(" ","/");
com=com.replaceAll("%","");
observationMediateur.obtenirListeReferentielCommune(this,com);
}
 
public void obtenirListeReferentielNom() {
String esp=espece.getText().replaceAll(" ","/");
esp=esp.replaceAll("%","");
observationMediateur.obtenirListeReferentielNom(this,esp);
}
 
public void ajouterObservation() {
if(departement.equals("000null") || departement.equals("")) {
String[] depCom = commune.getText().split(" ");
if(depCom.length > 1) {
String dep = depCom[1].replace('(', ' ');
dep =dep.replace(')', ' ');
dep = dep.trim();
dep = dep.replace('\\',' ');
dep = dep.trim();
try
{
int nDep = Integer.parseInt(dep);
if(nDep > 0 && nDep < 110) {
departement = dep ;
}
}
catch(NumberFormatException e)
{
departement = "" ;
}
}
}
 
Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue());
observationMediateur.ajouterObservation(obs);
}
private void modifierObservation() {
Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue());
obs.setNumeroOrdre(numeroOrdre);
observationMediateur.modifierObservation(obs);
}
private void supprimerObservation() {
observationMediateur.supprimerObservation(this, numeroOrdre);
}
 
public void afficherDetailsObservation(Observation obs)
{
raz() ;
char g ;
String idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/");
idLoc = idLoc.replaceAll("%","");
idLoc = idLoc.replaceAll("\"","");
idLoc = idLoc.replace('\\',' ');
idLoc = idLoc.trim();
if(!obs.getDate().equals("null") && !obs.getDate().equals("000null")) {
String[] dateEtHeure = obs.getDate().split(" ", 2);
if(verifierFormatDate(dateEtHeure[0])) {
date.setValue(dateEtHeure[0]) ;
}
else
{
date.setRawValue("");
}
}
if(!obs.getLieudit().equals("null") && !obs.getLieudit().equals("000null")) {
lieudit.setValue(obs.getLieudit()) ;
}
if(!obs.getStation().equals("null") && !obs.getStation().equals("000null")) {
station.setValue(obs.getStation()) ;
}
if(!obs.getMilieu().equals("null") && !obs.getMilieu().equals("000null")) {
milieu.setValue(obs.getMilieu()) ;
}
if(!obs.getCommentaire().equals("null") && !obs.getCommentaire().equals("000null")) {
comment.setValue(obs.getCommentaire()) ;
}
if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) {
if(!idLoc.equals("000null")) {
commune.setValue(obs.getLocalite()+" ("+idLoc+")") ;
}
else
{
commune.setValue(obs.getLocalite());
}
}
if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) {
departement = idLoc;
}
if(!obs.getNomSaisi().equals("null") && !obs.getNomSaisi().equals("000null")) {
espece.setValue(obs.getNomSaisi()) ;
}
if(!obs.getNumeroNomenclaturalSaisi().equals("null") && !obs.getNumeroNomenclaturalSaisi().equals("000null")) {
numeroNom = obs.getNumeroNomenclaturalSaisi() ;
}
if(!obs.getNumeroOrdre().equals("null") && !obs.getNumeroOrdre().equals("000nu2ll")) {
numeroOrdre = obs.getNumeroOrdre() ;
}
}
public void raz()
{
raz(Champs.TOUT);
}
public void raz(Champs champs)
{
switch (champs) {
case DATE:
date.reset() ;
break;
case LIEUDIT:
lieudit.reset() ;
break;
case STATION:
station.reset() ;
break;
case MILIEU:
milieu.reset() ;
break;
case COMMENT:
comment.reset() ;
break;
 
 
case COMMUNE:
commune.reset() ;
departement ="";
break;
case ESPECE:
espece.reset();
numeroNom = "" ;
numeroOrdre = "";
break;
case TOUT:
commune.reset();
date.reset() ;
lieudit.reset() ;
station.reset() ;
milieu.reset() ;
comment.reset() ;
milieu.reset() ;
departement ="";
espece.reset();
numeroNom = "" ;
numeroOrdre = "";
break;
 
}
}
private void setModification(String mode)
{
if(mode.equals("true")) {
 
boutonOK.setText("Modifier") ;
setTitle("Modification") ;
boutonAnnuler.setText("Supprimer") ;
modification = true ;
selecteurMode.removeClass("x-selec-crea") ;
selecteurMode.setCls("x-selec-modif") ;
}
else
{
 
boutonOK.setText("Ajouter") ;
setTitle("Saisir") ;
boutonAnnuler.setText("Réinitialiser") ;
modification = false ;
selecteurMode.removeClass("x-selec-modif") ;
selecteurMode.setCls("x-selec-crea") ;
}
}
/**
* renvoie vrai si on est en mode modification, faux si on est en mode création
* @return
*/
public boolean getModification()
{
return modification ;
}
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;
}
}
private void ajusterTailleChamps() {
int tailleChamps = (this.getInnerWidth()/100)*40;
this.tailleChamps = tailleChamps ;
commune.setWidth(tailleChamps);
station.setWidth(tailleChamps);
espece.setWidth(tailleChamps);
lieudit.setWidth(tailleChamps);
milieu.setWidth(tailleChamps);
comment.setWidth(tailleChamps);
 
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java
New file
0,0 → 1,131
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue;
 
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
 
/**
* Panneau contenant les filtres qu'on peut appliquer aux images
*
* @author aurelien
*
*/
public class PanneauFiltresObservationVues extends Panel {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* L'arbre pour la recherche entite geographique
*
*/
private ArbreEntiteGeographiqueObservationFiltreVue arbreEntiteGeographiqueObservationFiltreVue = null;
/**
* L'arbre pour la recherche date
*
*/
private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null;
private ArbreMotsClesFiltreVue arbreMotsClesFiltreVue = null ;
 
/**
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
*/
@SuppressWarnings("unused")
private PanneauFiltresObservationVues() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer
*/
public PanneauFiltresObservationVues(ObservationMediateur obs) {
super("Filtres");
observationMediateur = obs;
this.setCollapsible(true);
//this.setLayout(new AnchorLayout()) ;
this.setLayout(new RowLayout());
arbreEntiteGeographiqueObservationFiltreVue = new ArbreEntiteGeographiqueObservationFiltreVue(observationMediateur);
add(arbreEntiteGeographiqueObservationFiltreVue,new RowLayoutData());
//arbreEntiteGeographiqueObservationFiltreVue.setHeight(300) ;
arbreEntiteGeographiqueObservationFiltreVue.setWidth("100%") ;
arbreEntiteGeographiqueObservationFiltreVue.setBorder(false);
arbreDateObservationFiltreVue = new ArbreDateObservationFiltreVue(observationMediateur) ;
//arbreDateObservationFiltreVue.setHeight(300) ;
add(arbreDateObservationFiltreVue, new RowLayoutData());
arbreDateObservationFiltreVue.setWidth("100%") ;
arbreDateObservationFiltreVue.setBorder(false);
arbreMotsClesFiltreVue = new ArbreMotsClesFiltreVue(observationMediateur);
add(arbreMotsClesFiltreVue, new RowLayoutData());
arbreMotsClesFiltreVue.setWidth("100%") ;
arbreMotsClesFiltreVue.setTitle("Mots Clés");
arbreMotsClesFiltreVue.setTitleCollapse(true);
arbreMotsClesFiltreVue.setCollapsible(true);
arbreMotsClesFiltreVue.setBorder(false);
arbreMotsClesFiltreVue.hide();
}
 
/**
* Accesseur pour le filtre des mots clés
*
* @return le filtre des mots clés
*/
public ArbreEntiteGeographiqueObservationFiltreVue getArbreEntiteGeographiqueObservationFiltreVue() {
return arbreEntiteGeographiqueObservationFiltreVue;
}
public ArbreDateObservationFiltreVue getArbreDateObservationFiltreVue() {
return arbreDateObservationFiltreVue;
}
public ArbreMotsClesFiltreVue getArbreMotsClesFiltreVue() {
return arbreMotsClesFiltreVue;
}
/**
* Renvoie un booléen indiquant si un des filtres a été modifié
*
* @return true sur un des filtres est modifié, false sinon
*/
public boolean renvoyerEtatFiltre() {
 
return (arbreEntiteGeographiqueObservationFiltreVue.renvoyerEtatFiltre() || arbreDateObservationFiltreVue.renvoyerEtatFiltre());
}
 
/**
* Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre",
* "valeur"
*
* @return un tableau contenant les noms et les valeurs à filtrer
*/
public String[][] renvoyerValeursAFiltrer() {
String[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreMotsClesFiltreVue.renvoyerValeursAFiltrer()
};
return filtres;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java
New file
0,0 → 1,104
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
public class MenuObservationVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur;
 
/**
* Item pour la suppression d'obs
*/
private Item supprimerObservation = null;
private Item transmettreObservation = null;
private Item deTransmettreObservation = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuObservationVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuObservationVue(ObservationMediateur om) {
super();
 
oMediateur = om;
transmettreObservation = new Item("Rendre publiques les observations séléctionnées");
addItem(transmettreObservation);
deTransmettreObservation = new Item("Rendre privées les observations séléctionnées");
addItem(deTransmettreObservation);
supprimerObservation = new Item("Supprimer les observations séléctionnées");
addItem(supprimerObservation);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la suppression
if (item.equals(supprimerObservation)) {
// on notifie le médiateur
getOMediateur().supprimerObservations();
}
// si c'est la transmission
if (item.equals(transmettreObservation)) {
// on notifie le médiateur
getOMediateur().transmettreObservations(true);
}
// si c'est la detransmission
if (item.equals(deTransmettreObservation)) {
// on notifie le médiateur
getOMediateur().transmettreObservations(false);
}
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ObservationMediateur getOMediateur() {
return oMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/ArbreMotsClesObservationVue.java
New file
0,0 → 1,521
package org.tela_botanica.client.vues.observation;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
 
/**
* Le treepanel qui affiche l'arbre
*/
private static TreePanel arbreMotsCles = null;
/**
* L'éditeur qui permet de modifier les mots clés dans l'arbre
*/
private TreeEditor te = null;
/**
* Le textfield associé à l'éditeur
*/
private TextField tfEdit = null;
/**
* Bouton de validation
*/
private Button valider = null;
/**
* Une string permettant connaitre les mots clés cochés en cours séparés par
* des virgules
*/
private String motsClesEnCours = "";
/**
* Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
* (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
* du conteneur n'ai été effectué)
*/
private String[] motsClesEnAttente = new String[0];
/**
* Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
* noeud
*/
private boolean ajoutNoeud = false;
/**
* Booléen d'évènement qui sert à savoir si on est en train de modifier un
* noeud
*/
private boolean modifNoeud = false;
/**
* Booléen d'instanciation du conteneur
*/
private boolean arbreCharge = false;
/**
* Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
*/
private boolean motsCleInitialises;
 
/**
* Constructeur sans paramètre (privé car interdit d'utilisation)
*/
@SuppressWarnings("unused")
private ArbreMotsClesObservationVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesObservationVue(ObservationMediateur om) {
// on crée le panel
super("Mots clés");
this.setLayout(new VerticalLayout());
oMediateur = om;
 
// on crée le conteneur de l'arbre
arbreMotsCles = new TreePanel();
// on permet le drag and drop dans l'arbre
arbreMotsCles.setEnableDD(true);
arbreMotsCles.setId("x-view-tree-keyword-obs");
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine_obs");
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
arbreMotsCles.setWidth(500);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onClick(Node node, EventObject e) {
if(!arbreCharge) {
expand();
}
}
 
public void onExpand(Node node) {
if(!arbreCharge) {
obtenirArbreMotsCles();
arbreCharge = true;
}
}
});
 
// on crée l'éditeur pour l'arbre
tfEdit = new TextField();
tfEdit.setAutoWidth(true);
te = new TreeEditor(arbreMotsCles, tfEdit);
valider = new Button("Appliquer");
arbreMotsCles.add(te);
 
// on met en forme le layout
this.add(arbreMotsCles);
this.add(valider);
 
this.setBorder(false);
this.setCollapsible(true);
this.setTitleCollapse(true);
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Acesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
private ObservationMediateur getOMediateur() {
 
return oMediateur;
 
}
 
/**
* Acesseur pour l'arbre des mots clés
*
* @return le panel contenant l'arbre
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Accesseur pour l'éditeur
*
* @return l'éditeur associé à l'arbre
*/
public TreeEditor getTe() {
return te;
}
 
/**
* Acesseur pour le TextField associé à l'éditeur
*
* @return le champ texte associé à l'éditeur
*/
public TextField getTfEdit() {
return tfEdit;
}
 
/**
* Ajoute les listeners nécessaires pour la gestion des évènements
*/
private void ajouterListeners() {
arbreMotsCles.addListener(new TreePanelListenerAdapter() {
 
// gestion du clic sur un noeud
public void onClick(TreeNode node, EventObject e) {
 
e.stopEvent();
gererClicNoeud(node);
}
 
// gestion du clic droit sur un noeud
public void onContextMenu(TreeNode node, EventObject e) {
 
e.stopEvent();
getOMediateur().montrerContextMenuArbre(node, e, getTe());
 
}
 
// gestion du double clic sur un noeud
public void onDblClick(TreeNode node, EventObject e) {
 
modifNoeud = true;
if (!node.getId().equals("racine_obs")) {
te.startEdit(node);
}
}
 
// gestion de la modification du texte d'un noeud
public void onTextChange(TreeNode node, String text, String oldText) {
 
// on récupère les informations associées au noeud
TreeNode nd = node;
String[] usObject = new String[2];
usObject[0] = text;
usObject[1] = ((String[]) nd.getUserObject())[1];
nd.setUserObject(usObject);
 
// si c'est un nouveau noeud
if (ajoutNoeud) {
// on notifie le médiateur de l'ajout et on lui passe
// l'arbre
getOMediateur().ajouterMotCleDansArbre(nd,
getArbreMotsCles().getTree());
// et considère l'ajout achevé
ajoutNoeud = false;
}
// si c'est noeud déjà existant
else {
if (modifNoeud) {
// on notifie le médiateur de la modification et on lui
// passe l'arbre
getOMediateur().modifierMotCleDansArbre(nd,
getArbreMotsCles().getTree());
// et on considère la modification achevée
modifNoeud = false;
}
}
 
}
 
// gestion du déplacement d'un noeud
public void onMoveNode(Tree tree, TreeNode node,
TreeNode oldParent, TreeNode newParent, int index) {
// on notifie le médiateur et on lui passe l'arbre
getOMediateur().deplacerMotCleDansArbre(node,
getArbreMotsCles().getTree());
}
 
});
 
// gestion de la validation
valider.addListener(new ButtonListenerAdapter() {
 
// lors du clic
public void onClick(Button button, EventObject e) {
 
// on vide les mots clés en cours
motsClesEnCours = "";
// pour chaque noeud à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// on éxécute une fonction
public boolean execute(Node node) {
 
// on récupère le mot clé associé au noeud et
// ses infos
TreeNode tn = getArbreMotsCles().getNodeById(
node.getId());
 
String[] usObject = (String[]) tn
.getUserObject();
getOMediateur().mettreAjourMotsClesId(
usObject[0], usObject[1]);
 
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots
// clés en cours
motsClesEnCours += usObject[1] + ",";
}
 
return true;
}
 
});
 
// enfin on notifie le médiateur et on lui passe l'arbre et la
// liste des mots clés ainsi obtenue
getOMediateur().mettreAjourMotsCles(motsClesEnCours,
arbreMotsCles.getTree());
}
});
 
}
 
/**
* Envoie une demande au médiateur pour obtenir l'arbre des mots clés
*/
public void obtenirArbreMotsCles() {
 
getOMediateur().obtenirArbreMotsCles(this);
 
}
 
/**
* Supprime un noeud de l'arbre
*
* @param n
* le noeud à supprimer
*/
public void supprimerNoeud(TreeNode n) {
// si ça n'est pas la racine (qu'on ne peut pas supprimer)
if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
// on détache le noeud et on le détruit
n.getParentNode().removeChild(n);
n.destroy();
// puis on en notifie le médiateur en lui passant le noeud supprimé
// et l'arbre
getOMediateur()
.supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
} else {
// si l'utilisateur tente de supprimer la racine, on l'avertit de
// son erreur
Window.alert("Impossible de supprimer la racine de l'arbre");
}
}
 
/**
* Ajoute un noeud dans l'arbre au parent donné
*
* @param parent
* le futur parent du noeud à ajouter
*/
public void ajouterNoeud(TreeNode parent) {
 
// on met l'ajout du noeud à vrai
ajoutNoeud = true;
// on crée un nouveau noeud vide
TreeNode nd = new TreeNode("");
nd.setCls("x-view-treenode-keyword");
nd.setChecked(true);
// on associe un objet au noeud qui contient des infos
String[] usObject = new String[2];
// l'objet contient le nom du noeud
usObject[0] = "";
usObject[1] = genererIdMotCle(nd);
nd.setId(usObject[1]);
nd.setUserObject(usObject);
// l'identifiant d'un noeud c'est son hashcode
// l'objet associé au noeud contient aussi son identifiant
 
// on le concatène au parent et on étend ses enfants
parent.appendChild(nd);
parent.expand();
// enfin on place le curseur et on fait apparaitre le champ d'édition
// pour que l'utilisateur nomme son mot clé
te.startEdit(nd);
 
}
 
/**
* Coche le noeud s'il est décoché, le décoche sinon
*
* @param node
*/
public void gererClicNoeud(TreeNode node) {
if (node.getUI().isChecked()) {
node.getUI().toggleCheck(false);
} else {
node.getUI().toggleCheck(true);
}
}
 
/**
* Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
* clés à cocher
*
* @param motsClesIds
* un tableau contenant les identifiants des mots clés à cocher
*/
public void cocherMotsCles(final String[] motsClesIds) {
if (getArbreMotsCles() != null
&& getArbreMotsCles().getRootNode() != null) {
// à partir de la racine
getArbreMotsCles().getRootNode().cascade(
new NodeTraversalCallback() {
 
// pour chaque noeud
public boolean execute(Node node) {
 
getArbreMotsCles().getNodeById(node.getId())
.getUI().toggleCheck(false);
// on parcourt le tableau des mots clés
for (int i = 0; i < motsClesIds.length; i++) {
// si le mot clé fait partie des id à cocher on
// le coche
String usObject[] = (String[]) node
.getUserObject();
String nodeId = usObject[1];
 
if (nodeId.equals(motsClesIds[i])) {
getArbreMotsCles().getNodeById(nodeId+"_obs")
.getUI().toggleCheck(true);
return true;
}
}
// et on passe au suivant
return true;
}
 
});
}
else {
motsClesEnAttente = motsClesIds ;
}
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données pour l'objet
* @param repandreRafraichissement
* booleen qui dit si on doit répandre l'évenement
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
if(nouvelleDonnees instanceof Tree) {
 
Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
// on prend sa racine et on l'attache à l'arbre des mots clés
Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
 
// si l'arbre n'était pas encore considéré comme instancié
if (!arbreCharge) {
// on signale que oui
arbreCharge = true;
}
 
// s'il y a des mots clés en attente (lors du premier rendering)
if (motsCleInitialises == false && motsClesEnAttente != null) {
// on les coche
// cocherMotsCles(motsClesEnAttente) ;
motsCleInitialises = true;
}
if(motsClesEnAttente.length > 0) {
cocherMotsCles(motsClesEnAttente);
}
}
 
// Si on reçoit un tableau de String (cas ou l'on séléectionne une
// nouvelle image)
if (nouvelleDonnees instanceof String[]) {
// et que l'arbre est instancié
if (arbreCharge) {
// le tableau de String contient les id des mots clés associés à
// l'image
// on coche les mots clés contenu dans le tableau
String[] motsClesIds = (String[]) nouvelleDonnees;
cocherMotsCles(motsClesIds);
}
// si l'arbre n'est pas encore instancié on met les mots clés en
// attente
else {
motsClesEnAttente = (String[]) nouvelleDonnees;
}
}
}
 
private String genererIdMotCle(TreeNode nd) {
return "" + (nd.hashCode() + (Math.random() * 10000));
}
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1] +"_obs");
child.setChecked(false);
child.setUserObject(usObj);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/MiniZoomImageVue.java
New file
0,0 → 1,547
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
/**
* Panneau d'affichage d'une image avec des boutons précdents et suivant
*
* @author aurelien
*
*/
public class MiniZoomImageVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
 
/**
* Panneau conteneur pour l'image
*/
private Panel imageConteneur = null;
/**
* l'image à afficher
*/
private Image image = new Image("");
/**
* Bouton précédent
*/
private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
/**
* Bouton suivant
*/
private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
 
/**
* Taille originale Y de l'image
*/
private int imageHeight = 0;
 
/**
* Taille originale X de l'image
*/
private int imageWidth = 0;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
private String[] infosImages = null ;
private int index = 0 ;
 
/**
* Booleen d'initalisation général
*/
private boolean initialise = false;
 
/**
* Booleen d'initalisation du conteneur d'image
*/
private boolean conteneurInitialise = false;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MiniZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer à la vue
*/
public MiniZoomImageVue(ObservationMediateur im) {
super("Image liées");
setId("x-view-mini-zoom-panel");
// on associe le médiateur
oMediateur = im;
 
prev.setStylePrimaryName("x-view-zoom-button-p");
suiv.setStylePrimaryName("x-view-zoom-button-s");
 
// on crée une image qui gère le double clic et la roulette de la souris
image = new Image() {
 
public void onBrowserEvent(Event event) {
 
// lors d'un déplacement de la roulette
if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
 
// on simule un clic sur le bouton précédent
if (event.getMouseWheelVelocityY() >= 1) {
prev.click();
}
 
// ou suivant
if (event.getMouseWheelVelocityY() <= -1) {
suiv.click();
}
}
if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) {
event.preventDefault() ;
int[] xy = {event.getClientX(),event.getClientY()} ;
afficherMenu(xy) ;
}
}
};
image.setPixelSize(150, 150);
infosImages = new String[0] ;
 
this.setHeader(true);
 
imageConteneur = new Panel() ;
imageConteneur.setBorder(false);
 
imageConteneur.add(image);
imageConteneur.setId("x-view-mini-zoom-img");
 
// il n'existe pas de méthode pour ajouter un listener pour le double
// clic sur une image
// alors on lui dit manuellement de capter l'évènement double clic
image.sinkEvents(Event.ONDBLCLICK);
image.sinkEvents(Event.ONMOUSEWHEEL);
image.sinkEvents(Event.ONCONTEXTMENU) ;
 
// l'image de base est vide
image.setUrl("");
 
this.setLayout(new BorderLayout());
 
prev.setWidth("15%");
suiv.setWidth("15%");
 
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
 
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen qui dit si on doit répnadre l'évènement
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit une string
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise && ((String[])nouvelleDonnees).length != 0) {
infosImages = (String[]) nouvelleDonnees;
index = 0 ;
afficherImage() ;
} else {
// sinon on met une image vide
infosImages = new String[0] ;
getImage().setUrl("ill_liaison.png");
imageWidth = getImage().getWidth();
imageHeight = getImage().getHeight();
verifierEtRetaillerImage();
}
}
 
public void afficherImage()
{
// c'est l'url de l'image qu'on associe à la vue
if(infosImages.length != 0)
{
activerPanneau() ;
getImage().setUrl(convertirIdEnUrl(infosImages[index]));
imageWidth =getImage().getWidth();
imageHeight = getImage().getHeight();
verifierEtRetaillerImage();
}
else
{
desactiverPanneau() ;
}
}
 
/**
* Desactive visuellement le panneau et les boutons
*/
public void desactiverPanneau() {
getImage().setUrl("");
prev.setEnabled(false);
suiv.setEnabled(false);
}
 
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau() {
prev.setEnabled(true);
suiv.setEnabled(true);
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
 
// gestion du clic sur le bouton précedent
prev.addClickListener(new ClickListener() {
 
// en cas de clic
public void onClick(Widget sender) {
if(infosImages.length != 0) {
if(index == 0)
{
index = infosImages.length - 1 ;
}
else
{
index-- ;
}
afficherImage() ;
}
}
 
});
 
// gestion du clic sur le bouton suivant
suiv.addClickListener(new ClickListener() {
 
// en cas de clic
public void onClick(Widget sender) {
if(infosImages.length != 0) {
if(index == infosImages.length - 1)
{
index = 0 ;
}
else
{
index++ ;
}
afficherImage() ;
}
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ObservationMediateur getIMediateur() {
return oMediateur;
}
 
/**
* Accesseur au conteneur de l'image
*
* @return le conteneur de l'image
*/
public Image getImage() {
return image;
}
/**
* Acesseurs pour l'identifiant de l'image
* @return l'id de l'image
*/
public String getIdImage()
{
return infosImages[index] ;
}
 
/**
* Accesseur pour le bouton précédent
*
* @return le bouton précédent
*/
public com.google.gwt.user.client.ui.Button getPrev() {
return prev;
}
 
/**
* Accesseur pour le bouton suivant
*
* @return le bouton suivant
*/
public com.google.gwt.user.client.ui.Button getSuiv() {
return suiv;
}
 
/**
* Setter pour la taille de l'image
*
* @param x
* la largeur en pixels
* @param y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y) {
imageHeight = y;
imageWidth = x;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
idImage = id ;
}
 
/**
* renvoie la taille originale de l'image
*
* @return un tableau de deux entiers contenant la largeur puis la hauteur
*/
public int[] getTailleImage() {
int[] taille = { imageHeight, imageWidth };
 
return taille;
}
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
 
return imageConteneur;
 
}
 
public void raz() {
infosImages = new String[0] ;
getImage().setUrl("");
}
public void supprimerLiaisonImage() {
if(infosImages.length > 0) {
getImage().setUrl("") ;
int nouvelleTaille = infosImages.length - 1 ;
int indexSupp = index ;
String[] nouveauInfosImages = new String[nouvelleTaille] ;
int j = 0 ;
for(int i = 0 ; i < infosImages.length ; i++) {
if(i != indexSupp) {
nouveauInfosImages[j] = infosImages[i] ;
j++ ;
}
}
infosImages = nouveauInfosImages ;
index = 0 ;
afficherImage() ;
}
}
public void afficherMenu(int[] xy) {
Menu mn = new Menu() ;
final Item suppLiaison = new Item("Supprimer la liaison") ;
mn.addItem(suppLiaison) ;
mn.addListener(new MenuListenerAdapter() {
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'aide
if (item.equals(suppLiaison)) {
// on notifie le médiateur
getIMediateur().supprimerLiaisonObsImage() ;
}
}
}) ;
mn.showAt(xy) ;
}
public String convertirIdEnUrl(String idImg)
{
int maxZeros = 9 - idImg.length();
for (int j = 0; j < maxZeros; j++) {
idImg = "0" + idImg;
}
String baseUrl = Configuration.getImageBaseUrl() ;
 
String dossierNv1 = idImg.substring(0, 3);
String dossierNv2 = idImg.substring(3, 6);
String fichierNv = idImg.substring(6, 9);
 
String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv;
 
String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 };
String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/"
+ infosFichier[0] + "_M.jpg";
return urlImg ;
}
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
/*
// on prend la taille originale de l'image
int originalX = getTailleImage()[0];
int originalY = getTailleImage()[1];
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = imageConteneur.getWidth();
int tailleConteneurY = imageConteneur.getHeight();
int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
int max = Math.min(maxConteneur, 300);
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
// si la longueur de l'image est la plus grande des deux
int maxImage = Math.max(originalX, originalY);
if(maxImage == originalX) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = max;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
}
else
{
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = max;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
*/
// on modifie enfin la taille de l'image pour qu'elle soit affichée
int[] dim = calculerDimensions(getTailleImage());
getImage().setSize("" + dim[0] + "px",
"" + dim[1] + "px");
doLayout();
}
public int[] calculerDimensions(int[] tailleXY) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = Math.min(300,imageConteneur.getWidth()) ;
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;
}
}
 
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/InformationRepartitionVue.java
New file
0,0 → 1,203
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
 
/**
* Un panneau affichant la repartition d'une plante
*
* @author David Delon
*
*/
public class InformationRepartitionVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* l'image à afficher
*/
private Image image = new Image();
private String urlImage = "" ;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ;
com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private InformationRepartitionVue() {
super();
}
 
/**
* Constructeur avec argument
* @param obs le médiateur à associer
*/
public InformationRepartitionVue(ObservationMediateur obs) {
this.observationMediateur = obs;
imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
image = new Image() {
 
public void onBrowserEvent(Event event) {
 
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
 
// on notifie le médiateur
agrandirImage() ;
}
}
};
tp.applyTo(image.getElement()) ;
image.sinkEvents(Event.ONDBLCLICK);
this.setCls("x-image-info-rep") ;
add(image);
image.setPixelSize(150, 150);
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Affichage carte de repartition
*
*/
public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {
 
// si on recoit une String contenant une URL
if (nouvelleDonnees instanceof String) {
urlImage=(String) nouvelleDonnees;
if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) {
image.setUrl("ill_choro.png") ;
image.setPixelSize(150, 150);
}
else {
image.setUrl(urlImage);
verifierEtRetaillerImage();
}
}
}
public void agrandirImage() {
if(!imgZoom.isVisible())
{
String urlAgrandie = urlImage.replace("min", "max") ;
imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ;
imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ;
imgZoom.setAutoHeight(true) ;
imgZoom.setAutoWidth(true) ;
imgZoom.show(this.getElement()) ;
}
}
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
 
// on prend la taille originale de l'image
int originalX = image.getWidth();
int originalY = image.getHeight();
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = getWidth();
int tailleConteneurY = getHeight();
int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
int max = Math.min(maxConteneur, 300);
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
// si la longueur de l'image est la plus grande des deux
int maxImage = Math.max(originalX, originalY);
if(maxImage == originalX) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = max;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
}
else
{
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = max;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
image.setPixelSize(nouvelleTailleX ,
nouvelleTailleY);
doLayout();
}
 
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
}
public void raz() {
image.setUrl("");
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/ArbreEntiteGeographiqueObservationFiltreVue.java
New file
0,0 → 1,659
package org.tela_botanica.client.vues.observation;
 
import java.util.Comparator;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.core.client.GWT;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
import com.gwtext.client.core.EventObject;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
/**
* Les localites en cours
*/
private String entitesGeographiquesEncours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreEntitesGeographiques = null;
 
 
 
/**
* La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
*/
private Tree donneeEntitesGeographiques = new Tree();;
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
private boolean arbreCharge = false ;
 
private String nomFiltre = "" ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreEntiteGeographiqueObservationFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {
 
// on crée le panel
super("Localités");
this.observationMediateur = obs;
 
arbreEntitesGeographiques = new TreePanel();
 
this.setPaddings(5);
 
this.setCollapsible(true);
this.setAutoWidth(true);
if (GWT.isScript()) {
setAutoScroll(true);
}
 
 
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
}
 
/**
* Ajoute les listeners pour le rendu du panel
*/
private void ajouterListenersPanel() {
this.addListener(new PanelListenerAdapter() {
 
// on instancie réellement les composants au moment du rendu pour
// accélérer l'affichage
// et éviter des bugs
public void onRender(Component component) {
 
// on interdit le drag and drop dans l'arbre
arbreEntitesGeographiques.setEnableDD(false);
arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
arbreEntitesGeographiques.setAutoWidth(false);
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Localités");
root.setId("racine_entite");
String[] usObject = { "Localités" };
root.setUserObject(usObject);
 
arbreEntitesGeographiques.setRootNode(root);
arbreEntitesGeographiques.setRootVisible(true);
arbreEntitesGeographiques.setBorder(false);
root.setExpandable(true) ;
 
add(arbreEntitesGeographiques);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
// enfin on considère le composant comme instancié
estInstancie = true;
 
}
 
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des entites
*/
private void ajouterListeners() {
arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() {
public void onClick(TreeNode node, EventObject e) {
nomFiltre = "" ;
entitesGeographiquesEncours = "" ;
String nomPere = "" ;
String nomGrandPere = "" ;
switch(node.getDepth())
{
case 0:
if(!arbreCharge)
{
arbreEntitesGeographiques.getRootNode().expand();
}
else
{
observationMediateur.obtenirNombreObservation() ;
}
return ;
case 3: nomFiltre += "lieudit,location,id_location";
nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ;
break;
case 2: nomFiltre += "location,id_location";
nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
entitesGeographiquesEncours += node.getText()+","+nomPere ;
break;
case 1: nomFiltre += "id_location";
entitesGeographiquesEncours += node.getText() ;
break;
default:
break;
}
filtreModifie = true ;
observationMediateur.obtenirNombreObservation() ;
}
}) ;
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirListeEntiteGeographique() ;
arbreCharge = true ;
}
}
}) ;
}
public void initialiser() {
arbreCharge = false ;
arbreEntitesGeographiques.collapseAll();
// on vide l'ancien arbre
Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirListeEntiteGeographique() ;
arbreCharge = true ;
}
}
}) ;
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
String id_location=null;
String location=null;
String lieuDit=null;
ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
// on crée un arbre vide
Tree nouvelArbre = new Tree() ;
TreeNode root = new TreeNode();
root.setId("racine_entite");
root.setText("Localités");
String[] usObjRoot = { "Localités"};
root.setUserObject(usObjRoot);
nouvelArbre.setRootNode(root);
// on la parse et on récupère les informations qui nous interessent
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next());
id_location=ent.getIdLocation();
id_location = id_location.replaceAll("\"", "");
id_location = id_location.replace('\\',' ');
id_location = id_location.trim();
location=ent.getLocation();
lieuDit=ent.getLieuDit();
if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) {
id_location="Inconnue" ;
}
if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) {
location="Inconnue" ;
}
if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
lieuDit="Inconnue" ;
}
Node noeudMemeId = nouvelArbre.getNodeById(""+id_location);
// si la région existe déjà
if(noeudMemeId != null)
{
// on teste si la localité existe
Node noeudMemeLoc = nouvelArbre.getNodeById(""+(id_location+location));
if(noeudMemeLoc != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeLieu = nouvelArbre.getNodeById(""+(id_location+location+lieuDit));
if(noeudMemeLieu != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
noeudMemeLoc.appendChild(node_lieu) ;
String[] usObj = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj);
}
}
else
{
TreeNode node_loc = new TreeNode();
node_loc.setId(""+(id_location+location));
node_loc.setText(location);
noeudMemeId.appendChild(node_loc) ;
String[] usObj = {location,id_location+location};
node_loc.setUserObject(usObj);
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
node_loc.appendChild(node_lieu) ;
String[] usObj2 = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj2);
}
}
else
{
TreeNode node_id_loc = new TreeNode();
node_id_loc.setId(""+id_location);
node_id_loc.setText(id_location);
root.appendChild(node_id_loc) ;
String[] usObj = {id_location,id_location};
node_id_loc.setUserObject(usObj);
TreeNode node_loc = new TreeNode();
node_loc.setId(""+(id_location+location));
node_loc.setText(location);
node_id_loc.appendChild(node_loc) ;
String[] usObj2 = {location,id_location+location};
node_loc.setUserObject(usObj2);
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
node_loc.appendChild(node_lieu) ;
String[] usObj3 = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj3);
}
root.sort(comparerNoeuds()) ;
doLayout();
 
}
// on vide tous les noeuds
arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {
public boolean execute(Node node) {
node.remove();
return true;
}
});
copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode());
 
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
// l'état du filtre est réinitialisé
filtreModifie = false;
//show() ;
arbreEntitesGeographiques.doLayout();
 
}
if(nouvelleDonnees instanceof Observation)
{
// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
// de l'arbre
if(!arbreCharge) {
return;
}
Observation obs = (Observation)nouvelleDonnees ;
String id_location= obs.getIdentifiantLocalite();
id_location = id_location.replaceAll("\"", "");
id_location = id_location.replace('\\',' ');
id_location = id_location.trim();
String location=obs.getLocalite();
String lieuDit=obs.getLieudit();
Node root = arbreEntitesGeographiques.getRootNode() ;
if(id_location.contains("000null") || id_location.equals(null) || (id_location.trim()).equals("")) {
id_location="Inconnue" ;
}
if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) {
location="Inconnue" ;
}
if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
lieuDit="Inconnue" ;
}
Node noeudMemeId = arbreEntitesGeographiques.getNodeById(""+id_location);
// si la région existe déjà
if(noeudMemeId != null)
{
// on teste si la localité existe
Node noeudMemeLoc = arbreEntitesGeographiques.getNodeById(""+(id_location+location));
if(noeudMemeLoc != null)
{
// enfin on teste si le lieu dit existe
Node noeudMemeLieu = arbreEntitesGeographiques.getNodeById(""+(id_location+location+lieuDit));
if(noeudMemeLieu != null)
{
// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
}
else
{
// enfin on ne crée que le noeud du lieu dit
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
String[] usObj = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj);
noeudMemeLoc.appendChild(node_lieu) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
TreeNode node_loc = new TreeNode();
node_loc.setId(""+(id_location+location));
node_loc.setText(location);
String[] usObj = {location,id_location+location};
node_loc.setUserObject(usObj);
noeudMemeId.appendChild(node_loc) ;
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
String[] usObj2 = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj2);
node_loc.appendChild(node_lieu) ;
root.sort(comparerNoeuds()) ;
}
}
else
{
// TODO: Pourquoi l'ajout ne marche que sur la racine ?
TreeNode node_id_loc = new TreeNode();
node_id_loc.setId(""+id_location);
node_id_loc.setText(id_location);
String[] usObj = {id_location,id_location};
node_id_loc.setUserObject(usObj);
root.appendChild(node_id_loc) ;
TreeNode node_loc = new TreeNode();
node_loc.setId(""+(id_location+location));
node_loc.setText(location);
String[] usObj2 = {location,id_location+location};
node_loc.setUserObject(usObj2);
node_id_loc.appendChild(node_loc) ;
TreeNode node_lieu = new TreeNode();
node_lieu.setId(""+(id_location+location+lieuDit));
node_lieu.setText(lieuDit);
String[] usObj3 = {lieuDit,id_location+location+lieuDit};
node_lieu.setUserObject(usObj3);
node_loc.appendChild(node_lieu) ;
root.sort(comparerNoeuds()) ;
}
arbreEntitesGeographiques.doLayout() ;
}
}
 
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreEntitesGeographiques;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
public String renvoyerNomFiltre() {
 
return "Localités";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
public String[] renvoyerValeursAFiltrer() {
 
valider();
String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ;
 
return valeursFiltrees;
}
 
/**
* Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
* copie du sous arbre du premier noeud, qu'elle concatène au deuxième
*
* @param ndPereOriginal
* le père des noeuds de l'arbre original
* @param ndPereCopie
* le père qui va recevoir les copies
*/
private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
if (ndPereCopie != null && ndPereOriginal != null) {
Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 
for (int i = 0; i < ndNodeFils.length; i++) {
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setUserObject(usObj);
child.setId(""+usObj[1]);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
 
/**
* Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
*/
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
public void valider() {
if (estInstancie) {
}
}
public Comparator<TreeNode> comparerNoeuds()
{
return new Comparator<TreeNode>() {
 
public int compare(TreeNode o1, TreeNode o2) {
if(o1.getText().equals("Inconnue")) {
return -1 ;
}
if(o2.getText().equals("Inconnue")) {
return 1 ;
}
if(o1.getDepth() == 1 && o2.getDepth() == 1)
{
String l1 = o1.getText() ;
String l2 = o2.getText() ;
if(l1.length() == 1) {
l1 = "0"+l1;
}
if(l2.length() == 1) {
l2 = "0"+l2;
}
Integer n1 = 0;
Integer n2 = 0;
try{
n1 = Integer.parseInt(l1) ;
n2 = Integer.parseInt(l2) ;
} catch(NumberFormatException ne) {
n1 = 0;
n2 = 0;
}
return n1.compareTo(n2) ;
}
else
{
String n1 = o1.getText() ;
String n2 = o2.getText() ;
return n1.compareTo(n2) ;
}
}
} ;
}
 
public void raz() {
arbreCharge = false ;
arbreEntitesGeographiques.collapseAll();
arbreEntitesGeographiques.clear() ;
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Localités");
root.setId("racine_entite");
String[] usObject = { "Localités" };
root.setUserObject(usObject);
 
arbreEntitesGeographiques.setRootNode(root);
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
public void onExpand(Node node) {
if(!arbreCharge)
{
observationMediateur.obtenirDatesObservation() ;
arbreCharge = true ;
}
}
}) ;
arbreCharge = false ;
this.doLayout() ;
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/ImageGeneriqueVue.java
New file
0,0 → 1,202
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
 
/**
* Un panneau affichant une image generique provenant d eflore
*
* @author David Delon
*
*/
public class ImageGeneriqueVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
private ObservationMediateur observationMediateur = null;
/**
* l'image à afficher
*/
private Image image = new Image();
private String urlImage = "" ;
private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ImageGeneriqueVue() {
super();
}
 
/**
* Constructeur avec argument
* @param obs le médiateur à associer
*/
public ImageGeneriqueVue(ObservationMediateur obs) {
this.observationMediateur = obs;
imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
image = new Image() {
 
public void onBrowserEvent(Event event) {
 
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
 
// on notifie le médiateur
agrandirImage() ;
}
}
};
tp.applyTo(image.getElement()) ;
this.setCls("x-image-gen") ;
 
add(image);
image.setPixelSize(150, 150);
image.sinkEvents(Event.ONDBLCLICK);
// on ajoute les listeners
ajouterListeners();
 
}
 
 
/**
* Affichage image generique
*
*/
public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {
 
// si on recoit une String contenant une URL
if (nouvelleDonnees instanceof String) {
urlImage=(String) nouvelleDonnees;
if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) {
image.setUrl("ill_taxon.png") ;
image.setPixelSize(150, 150);
}
else {
image.setUrl(urlImage);
verifierEtRetaillerImage();
}
}
observationMediateur.deMasquerChargementInfosObservations() ;
}
public void agrandirImage() {
if(!imgZoom.isVisible())
{
String urlAgrandie = urlImage.replace("min", "max") ;
imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ;
imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ;
imgZoom.setAutoHeight(true) ;
imgZoom.setAutoWidth(true) ;
imgZoom.show(this.getElement()) ;
}
 
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
}
public void raz() {
image.setUrl("");
}
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
 
// on prend la taille originale de l'image
int originalX = image.getWidth();
int originalY = image.getHeight();
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = getWidth();
int tailleConteneurY = getHeight();
int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
int max = Math.min(maxConteneur, 300);
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
// si la longueur de l'image est la plus grande des deux
int maxImage = Math.max(originalX, originalY);
if(maxImage == originalX) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = max;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
}
else
{
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = max;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
image.setPixelSize(nouvelleTailleX ,
nouvelleTailleY);
doLayout();
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java
New file
0,0 → 1,207
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextArea;
 
public class SaisieMotsClesVue extends Window implements Rafraichissable {
private ObservationMediateur oMediateur = null ;
private Object[][] listeMotsPesee = null;
private String motsAAjouter = "" ;
private int nbMotsClesMax = 1 ;
private TextArea motsClesAjout = null;
private Button validerAjout = null ;
private Button voirCacherNuage = null;
private boolean nuageVisible = false ;
private Panel contenuNuage = null ;
public SaisieMotsClesVue(ObservationMediateur om) {
super("Entrez vos mots clés");
setCls("fenmotcles");
oMediateur = om ;
setWidth(300);
motsClesAjout = new TextArea();
motsClesAjout.setWidth(300);
validerAjout = new Button("Valider");
voirCacherNuage= new Button("Afficher les mots clés");
final Rafraichissable r = this ;
this.setCloseAction(CLOSE);
validerAjout.addListener(new ButtonListenerAdapter() {
public void onClick(Button button, EventObject e) {
motsAAjouter = motsClesAjout.getText();
//oMediateur.AjouterMotsClesEnMasse(motsAAjouter);
}
});
voirCacherNuage.addListener(new ButtonListenerAdapter() {
public void onClick(Button button, EventObject e) {
if(nuageVisible) {
if(contenuNuage != null) {
contenuNuage.clear();
}
voirCacherNuage.setText("Afficher les mots clés");
nuageVisible = false;
}
else {
// oMediateur.obtenirNuageMotsCles(r);
voirCacherNuage.setText("Cacher les mots clés");
nuageVisible = true;
}
}
});
add(motsClesAjout);
add(validerAjout);
add(voirCacherNuage);
contenuNuage = new Panel();
contenuNuage.setBorder(false);
add(contenuNuage);
}
 
public boolean renvoyerEtatFiltre() {
// TODO Auto-generated method stub
return false;
}
 
 
public String renvoyerNomFiltre() {
// TODO Auto-generated method stub
return null;
}
 
 
public String[] renvoyerValeursAFiltrer() {
// TODO Auto-generated method stub
return null;
}
 
 
public void valider() {
// TODO Auto-generated method stub
}
 
 
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof Integer) {
nbMotsClesMax = (Integer)nouvelleDonnees;
demasquerChargement();
}
if(nouvelleDonnees instanceof Object[][]) {
listeMotsPesee = (Object[][])nouvelleDonnees ;
construireNuage();
demasquerChargement();
}
if(nouvelleDonnees instanceof String) {
String res = (String)nouvelleDonnees;
if(res.equals("OK")) {
masquerChargement();
oMediateur.obtenirListeObservation();
//oMediateur.obtenirNuageMotsCles(this);
}
}
}
private void construireNuage() {
contenuNuage.clear();
String contenu = "<ul class=\"nuagetag\">" ;
for(int i = 0; i<listeMotsPesee.length; i++) {
String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ;
contenu += "<li class=\""+classeMotCle+"\">";
contenu += (String)listeMotsPesee[i][0];
contenu += "</li>";
}
contenu += "</ul>" ;
HTML contenuHTML = new HTML(contenu) {
public void onBrowserEvent(Event e) {
motsAAjouter += " "+e.getTarget().getInnerHTML();
motsClesAjout.setValue(motsAAjouter);
}
};
contenuHTML.sinkEvents(Event.ONCLICK);
contenuNuage.add(contenuHTML);
contenuNuage.doLayout();
doLayout();
}
private int calculerPoids(int poidMot) {
int poids = (poidMot*10)/nbMotsClesMax;
if(poids < 1) {
return 1;
}
return poids;
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
 
if (masked!=null) {
masked.mask("Chargement") ;
}
 
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
masked.unmask() ;
}
}
 
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/observation/NuageMotsClesVue.java
New file
0,0 → 1,166
package org.tela_botanica.client.vues.observation;
 
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
 
public class NuageMotsClesVue extends Window implements Filtrable, Rafraichissable {
 
private ObservationMediateur oMediateur = null ;
private Object[][] listeMotsPesee = null;
private String motsAChercher = "" ;
private int nbMotsClesMax = 1 ;
private boolean nuageCharge = false ;
public NuageMotsClesVue(ObservationMediateur om) {
super("Nuage de mots clés");
setCls("fenmotcles");
oMediateur = om ;
setWidth(200);
this.setCloseAction(CLOSE);
//oMediateur.obtenirNuageMotsCles(this);
this.addListener(new ContainerListenerAdapter() {
 
@Override
public void onAfterLayout(Container self) {
if(!nuageCharge) {
masquerChargement();
}
}
 
@Override
public void onRender(Component component) {
}
 
@Override
public void onShow(Component component) {
// TODO Auto-generated method stub
}
});
}
 
public boolean renvoyerEtatFiltre() {
// TODO Auto-generated method stub
return false;
}
 
 
public String renvoyerNomFiltre() {
// TODO Auto-generated method stub
return null;
}
 
 
public String[] renvoyerValeursAFiltrer() {
// TODO Auto-generated method stub
return null;
}
 
 
public void valider() {
// TODO Auto-generated method stub
}
 
 
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
if(nouvelleDonnees instanceof Integer) {
nbMotsClesMax = (Integer)nouvelleDonnees;
}
if(nouvelleDonnees instanceof Object[][]) {
listeMotsPesee = (Object[][])nouvelleDonnees ;
construireNuage();
}
}
private void construireNuage() {
String contenu = "<ul class=\"nuagetag\">" ;
for(int i = 0; i<listeMotsPesee.length; i++) {
String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ;
contenu += "<li class=\""+classeMotCle+"\">";
contenu += (String)listeMotsPesee[i][0];
contenu += "</li>";
}
contenu += "</ul>" ;
HTML contenuHTML = new HTML(contenu) {
public void onBrowserEvent(Event e) {
//oMediateur.ajouterMotCleRecherche(e.getTarget().getInnerHTML());
}
};
contenuHTML.sinkEvents(Event.ONCLICK);
this.clear();
this.add(contenuHTML);
doLayout();
nuageCharge = true;
demasquerChargement();
}
private int calculerPoids(int poidMot) {
int poids = (poidMot*10)/nbMotsClesMax;
if(poids < 1) {
return 1;
}
return poids;
}
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
 
if (masked!=null) {
masked.mask("Chargement") ;
}
 
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
masked.unmask() ;
}
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/EtatConnexionVue.java
22,18 → 22,13
import org.tela_botanica.client.modeles.Configuration;
 
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Widget;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListener;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
 
 
69,7 → 64,6
*
*/
private boolean connecte = false ;
public EtatConnexionVue(CarnetEnLigneMediateur cm) {
310,7 → 304,6
});
}
 
this.connecte = connecte;
}
 
/trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
24,13 → 24,9
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
 
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.KeyboardListener;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.PopupListener;
import com.google.gwt.user.client.ui.PopupPanel;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Position;
import com.gwtext.client.widgets.Button;
/trunk/src/org/tela_botanica/client/vues/image/MenuIdVue.java
New file
0,0 → 1,84
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
public class MenuIdVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour le changement d'utilisateur
*/
private Item changerId = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuIdVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuIdVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
// on construit le menu
changerId = new Item("Changer d'utilisateur");
addItem(changerId);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la recherche par commentaires
if (item.equals(changerId)) {
// on notifie le médiateur
getIMediateur().afficherMenuId();
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/DateFiltreVue.java
New file
0,0 → 1,149
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.form.DateField;
 
/**
* Classe implémentant un filtre qui permet de rechercher une image par rapport
* à la date associée, des critères plus fins viendront compléter cela
*
* @author aurelien
*
*/
public class DateFiltreVue extends Panel implements Rafraichissable, Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Le widget calendrier
*/
private DateField filtreDate = null;
 
/**
* Booleen d'état du filtre
*/
private boolean filtreModifie = false;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private DateFiltreVue() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer
*/
public DateFiltreVue(ImageMediateur im) {
super();
setPaddings(5);
setCollapsible(true);
setBorder(false);
iMediateur = im;
 
Label labelRecherche = new Label("Par date :");
add(labelRecherche);
 
// on crée le calendrier et on définit le format de la date "jj/mm/aaaa"
filtreDate = new DateField();
filtreDate.setAutoWidth(true);
filtreDate.setFormat("d/m/Y");
 
add(filtreDate);
ajouterListeners();
}
 
/**
* Ajoute les listeners
*/
public void ajouterListeners() {
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
filtreModifie = false;
 
}
 
/**
* Méthode héritée de l'interface filtrable
*/
public void valider() {
 
filtreModifie = true;
 
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
@SuppressWarnings("unused")
private ImageMediateur getIMediateur() {
 
return iMediateur;
}
 
/**
* Méthode héritée de l'interface filtrable
*/
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
/**
* Méthode héritée de l'interface filtrable
*/
public String renvoyerNomFiltre() {
 
return "Recherche par date";
}
 
/**
* Méthode héritée de l'interface filtrable
*/
public String[] renvoyerValeursAFiltrer() {
 
// si la date est valide
if (filtreDate.isValid()) {
// on en sépare les composants
String dt = filtreDate.getRawValue();
String[] dates = dt.split("/");
if (dates.length == 3) {
// qu'on réassemble dans un autre format (américain) pour la
// base de donnée "aaaa-mm-jj"
String dateFormatee = dates[2] + "-" + dates[1] + "-"
+ dates[0];
String[] valeursFiltres = { "ci_meta_date", dateFormatee };
return valeursFiltres;
}
}
 
// si la date n'estp as valide on renvoie une chaine vide (ce qui
// correspond à n'importe qu'elle date)
String dateFormatee = "";
String[] valeursFiltres = { "ci_meta_date", dateFormatee };
return valeursFiltres;
 
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/ListeImageVue.java
New file
0,0 → 1,530
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import org.tela_botanica.client.vues.BarrePaginationVue;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.grid.CellMetadata;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.Renderer;
import com.gwtext.client.widgets.grid.RowSelectionModel;
import com.gwtext.client.widgets.grid.event.GridRowListener;
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
 
/**
* Liste d'image composée de miniatures et d'information sur l'image, implémente
* l'interface rafraichissable et l'interface vueListable
*
* @author aurelien
*/
public class ListeImageVue extends GridPanel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Config de colonne
*/
private ColumnConfig numImage;
/**
* Config de colonne
*/
private ColumnConfig 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;
/**
* 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;
 
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
private ListeImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer
*/
public ListeImageVue(ImageMediateur im) {
 
new ListeImageVue();
 
this.setId("listeImageGrid");
// on associe le médiateur
this.iMediateur = im;
 
// on place la barre de pagination
bt = new BarrePaginationVue(this);
bt.setLabelElement("Images");
bt.setTaillePageParDefaut(50);
setBottomToolbar(bt);
 
// on construit le modèle de colonnes
numImage = new ColumnConfig("numéro", "num_image", 30, true,
new Renderer() {
 
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
 
String ImgNum = record.getAsString("num_image");
return "<div class=\"centered-list\">" + ImgNum
+ "</div>";
}
 
});
 
datImage = new ColumnConfig("date", "dat_image", 120, true,
new Renderer() {
 
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
 
String ImgDat = record.getAsString("dat_image");
if (ImgDat == null) {
ImgDat = " ";
}
return "<div class=\"centered-list\">" + ImgDat
+ "</div>";
}
 
});
lieImage = new ColumnConfig("lieu", "lie_image", 120, true,
new Renderer() {
 
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
 
String ImgLie = record.getAsString("lie_image");
if (ImgLie == null) {
ImgLie = " ";
}
return "<div class=\"centered-list\">" + ImgLie
+ "</div>";
}
 
});
appImage = new ColumnConfig("appareil", "app_image", 120, true,
new Renderer() {
 
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
 
String ImgApp = record.getAsString("app_image");
if (ImgApp == null) {
ImgApp = " ";
}
return "<div class=\"centered-list\">" + ImgApp
+ "</div>";
}
 
});
// la colonne url possède une méthode de rendu spéciale
urlImage = new ColumnConfig("Image", "url_image_S", 30, true,
new Renderer() {
 
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
// on affiche une div contenant l'image pointée par
// l'url
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 + "'> </div>";
}
 
});
 
noteImage = new ColumnConfig("note", "note_image", 80, true,
new Renderer() {
public String render(Object value,
CellMetadata cellMetadata, Record record,
int rowIndex, int colNum, Store store) {
 
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;
 
}
 
});
 
// on associe le modèle de colonnes
ColumnConfig[] cm = { numImage, urlImage, datImage, lieImage, appImage,
noteImage };
modeleColonnes = new ColumnModel(cm);
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
this.setAutoWidth(true);
this.setEnableColumnResize(true);
 
// creation du store
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defNoteImage = new StringFieldDef("note_image");
FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
defNoteImage };
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
this.setStore(st);
this.getView().setAutoFill(true);
 
 
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("chargement");
//Enable drag and drop
this.setEnableDragDrop(true);
//You need to set the same group for both grids
this.setDdGroup("DragGroupName");
 
// on ajoute les listeners
ajouterListeners();
 
}
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
this.addListener(new ContainerListenerAdapter() {
 
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é
 
public void onRender(Component component) {
 
if (!isEstInstancie()) {
setEstInstancie(true);
setDragDropText("Glissez les images sur la liste d'observation pour les lier") ;
getIMediateur().synchroniserSelection("galerie");
}
}
 
public void onShow(Component component) {
 
}
 
});
 
this.addGridRowListener(new GridRowListener() {
 
// gestion du clic sur une ligne
public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {
 
// on notifie le médiateur et on lui passe le nuémro de ligne
getIMediateur().clicListeImage(rowIndex);
}
 
// gestion du clic droit
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
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
 
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)
{
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 ;
}
}
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
*/
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
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit un store
if (nouvelleDonnees instanceof Store) {
 
// on affecte celui-ci comme gestionnaire de données
st = (Store) nouvelleDonnees;
st.load();
// et on reconfigure et rafraichit la vue
this.reconfigure(st, this.getColumnModel());
 
}
 
// si on doit répandre l'évenement
if (repandreRafraichissement) {
// on notifie le médiateur avec une copie des données
getIMediateur().synchroniserDonneesZoomListeGalerie(
nouvelleDonnees, this);
}
}
 
/**
* Sélectionne des enregistrements donné
*
* @param sel
* un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
if (isEstInstancie()) {
getSelectionModel().clearSelections();
getSelectionModel().selectRecords(sel);
}
}
 
/**
* Accesseur pour la toolbar de pagination
*
* @return la toolbar de pagination
*/
public BarrePaginationVue getToolBarVue() {
return bt;
}
 
/**
* Setteur pour le booleen d'instanciation
*
* @param estInstancie
* la nouvelle valeur du booleen
*/
public void setEstInstancie(boolean estInstancie) {
this.estInstancie = estInstancie;
}
 
public void mettreAjourInfos(String commentaires, String date, String note) {
 
for (int i = 0; i < getSelectionModel().getCount(); i++) {
 
getSelectionModel().getSelections()[i].set("note_image", note);
getSelectionModel().getSelections()[i].set("dat_image", date);
 
}
 
}
public void changerNumeroPage(int pageCourante) {
iMediateur.changerNumeroPage(pageCourante) ;
}
 
public void changerTaillePage(int nouvelleTaillePage) {
iMediateur.changerTaillePage(nouvelleTaillePage) ;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java
New file
0,0 → 1,134
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
import com.gwtext.client.core.EventObject;;
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
public class MenuLiaisonVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour lier la selection d'images aux observations selectionnées
*/
private Item lierSelection = null ;
 
/**
* Item pour afficher la selection d'images
*/
private Item afficherSelection = null;
/**
* Item pour supprimer la liaison entre une observation et une image
*/
private Item supprimerLiaison = null ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuLiaisonVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuLiaisonVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
// on construit le menu
lierSelection = new Item("Lier le tampon à la sélection d'observation");
afficherSelection = new Item("Afficher le tampon");
 
addItem(lierSelection);
addItem(afficherSelection);
 
// on ajoute les listeners
ajouterListeners();
}
 
public MenuLiaisonVue(ImageMediateur mediateur, boolean liaison) {
iMediateur = mediateur;
lierSelection = new Item("Lier le tampon à la sélection d'observation");
afficherSelection = new Item("Afficher le tampon");
addItem(lierSelection);
addItem(afficherSelection);
iMediateur = mediateur;
if(liaison) {
supprimerLiaison = new Item("Supprimer la liaison") ;
addItem(supprimerLiaison);
}
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la suppression
if (item.equals(lierSelection)) {
// on notifie le médiateur
getIMediateur().LierTamponObservations();
}
 
// si c'est la liaison
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
if(item.equals(supprimerLiaison)) {
getIMediateur().supprimerLiaisonObsImage() ;
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/BarreNotationVue.java
New file
0,0 → 1,223
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.MouseListenerAdapter;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.widgets.Panel;
 
/**
* Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique,
* utilisant Ajax (et pas CSS)
*
* @author aurelien
*
*/
public class BarreNotationVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé
*/
@SuppressWarnings("unused")
private ImageMediateur iMediateur = null;
/**
* La note actuellement affichée
*/
private int noteEnCours = 0;
/**
* La note maximum
*/
private int noteMax = 0;
/**
* Booléen indiquant si une note est affectée à la barre en ce moment
*/
private boolean estNote = false;
/**
* Tablmeau d'images contenant les étoiles affichées
*/
private Image[] etoiles = null;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreNotationVue() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer à la vue
* @param noteMax
* la note maximale
*/
public BarreNotationVue(ImageMediateur im, int noteMax) {
iMediateur = im;
setNoteMax(noteMax);
this.setSize(200, 100);
this.setBodyBorder(false);
this.setBorder(false);
this.setCls("x-view-notation");
 
ajouterListeners();
 
}
 
public void ajouterListeners() {
for (int i = 0; i < etoiles.length; i++) {
 
etoiles[i].addMouseListener(new MouseListenerAdapter() {
 
// si la souris passe sur la barre
public void onMouseEnter(Widget sender) {
 
Image enCours = (Image) sender;
 
// on met en surbrillance toutes les étoiles allant de la
// première jusqu'à
// celle sous le curseur
for (int i = 0; etoiles[i] != enCours; i++) {
etoiles[i].setUrl("note-hover.gif");
}
enCours.setUrl("note-hover.gif");
 
}
 
// si la souris sort de la barre
public void onMouseLeave(Widget sender) {
 
// on affiche la véritable note
afficherNote();
}
 
});
 
etoiles[i].addClickListener(new ClickListener() {
// si on clique sur une étoiles
public void onClick(Widget sender) {
 
int i = 0;
 
// on récupère le numéro de l'étoile sur laquelle on a
// cliqué
while (etoiles[i] != (Image) sender) {
i++;
}
// et on affecte la note
noter(i);
 
}
 
});
}
 
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on recoit un tableau de string
if (nouvelleDonnees instanceof String[]) {
// on récupère le premier élément (un entier, qui contient la note)
String[] note = (String[]) nouvelleDonnees;
int noteInt = Integer.parseInt(note[0]);
 
// si l'entier est une note valide
if (noteInt != -1 && noteInt >= 0) {
 
noter(noteInt);
}
// sinon si l'entier vaut -1
else {
// alors on note avec 0
// et on met le booleen de notation a false (qui signifie que
// l'image n'est pas encore notée)
estNote = false;
noteEnCours = 0;
// et demande l'affichage
afficherNote();
}
 
}
 
}
 
/**
* Affecte une note à la barre et rafraichit l'affichage
*
* @param note
* la nouvelle note
*/
public void noter(int note) {
// on affecte la note
noteEnCours = note;
// on met le boolean de notation à true (l'image est notée)
estNote = true;
// et on demande l'affichage
afficherNote();
}
 
/**
* Setteur pour la note maximale
*
* @param nMax
* la nouvelle note maximale
*/
public void setNoteMax(int nMax) {
// on affecte la note
noteMax = nMax;
// on prépare le tableau d'image
etoiles = new Image[noteMax];
 
// qu'on remplit par defaut avec des images d'étoiles vides
for (int i = 0; i < noteMax; i++) {
etoiles[i] = new Image("note_off.gif");
etoiles[i].setStylePrimaryName("x-view-notation-bar");
this.add(etoiles[i]);
}
}
 
/**
* Affiche la note d'une image sous la forme d'étoiles
*/
public void afficherNote() {
// si l'image est notée
if (estNote) {
// on affiche autant d'étoiles que le chiffre de la note
for (int i = 0; i <= noteEnCours; i++) {
etoiles[i].setUrl("note-on.gif");
}
// et si elle est inférieure à la note maximale, on remplit le reste
// par des étoiles vides
for (int j = noteEnCours + 1; j < noteMax; j++) {
etoiles[j].setUrl("note-off.gif");
}
}
// sinon
else {
// on remplit toute la barre avec des étoiles vides
for (int i = 0; i < noteMax; i++) {
etoiles[i].setUrl("note-off.gif");
}
}
 
}
 
/**
* Accesseur pour la note en cours sous forme de string
*
* @return la note en cours sous forme d'une chaine de charactères
*/
public String getNote() {
return "" + noteEnCours;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/MenuImageVue.java
New file
0,0 → 1,178
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.MenuItem;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
/**
* Menu de gestion des images
*
* @author aurelien
*
*/
public class MenuImageVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour l'upload
*/
private MenuItem uploaderImage = null;
/**
* Item pour la suppression
*/
private Item supprimerImage = null;
 
/**
* Item pour l'ajout d'images à la selection
*/
private Item ajouterImageSelection = null;
 
/**
* Item pour vider la selection d'images
*/
private Item viderSelection = null;
 
/**
* Item pour lier la selection d'images
*/
private Item afficherSelection = null;
private Item uploadMultiple = null ;
private Item uploadSimple = null ;
private Menu mn = null ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuImageVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuImageVue(ImageMediateur im) {
super();
 
iMediateur = im;
mn = new Menu();
uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois");
uploadSimple = new Item("Un fichier à la la fois");
mn.addItem(uploadMultiple);
mn.addItem(uploadSimple);
 
// on construit le menu
uploaderImage = new MenuItem("Ajouter des images", mn);
supprimerImage = new Item("Supprimer les images selectionnées");
ajouterImageSelection = new Item(
"Ajouter les images sélectionnées au tampon");
viderSelection = new Item("Vider le tampon");
afficherSelection = new Item("Afficher le tampon");
addItem(uploaderImage);
addItem(supprimerImage);
addSeparator() ;
addItem(ajouterImageSelection);
addItem(viderSelection);
addItem(afficherSelection);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
public void onItemClick(BaseItem item, EventObject e) {
// si c'est la suppression
if (item.equals(supprimerImage)) {
// on notifie le médiateur
getIMediateur().supprimerImages();
}
 
// si c'est l'ajout à la sélection
if (item.equals(ajouterImageSelection)) {
getIMediateur().ajouterImagesSelection();
}
 
// si c'est le vidage de la sélection
if (item.equals(viderSelection)) {
getIMediateur().viderSelection();
}
 
// si c'est l'affichage de la selection
if (item.equals(afficherSelection)) {
getIMediateur().afficherIdSelectionImages();
}
// enfin, on cache le menu
hide();
 
}
public void onShow(Menu menu) {
if(getIMediateur().getCompteSelection() != 0) {
afficherSelection.enable();
viderSelection.enable();
}
else {
afficherSelection.disable();
viderSelection.disable();
}
}
 
});
mn.addListener(new MenuListenerAdapter() {
public void onItemClick(BaseItem item, EventObject e) {
// si c'est l'upload
if (item.equals(uploadMultiple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(true);
}
// si c'est l'upload
if (item.equals(uploadSimple)) {
// on notifie le médiateur
getIMediateur().uploaderImages(false);
}
}
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/ZoomImageVue.java
New file
0,0 → 1,461
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
 
/**
* Panneau d'affichage d'une image avec des boutons précdents et suivant
*
* @author aurelien
*
*/
public class ZoomImageVue extends Panel implements Rafraichissable {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Panneau conteneur pour l'image
*/
private Panel imageConteneur = null;
/**
* l'image à afficher
*/
private Image image = new Image("vide.jpg");
/**
* Bouton précédent
*/
private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
/**
* Bouton suivant
*/
private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
 
/**
* Taille originale Y de l'image
*/
private int imageHeight = 0;
 
/**
* Taille originale X de l'image
*/
private int imageWidth = 0;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
 
/**
* Booleen d'initalisation général
*/
private boolean initialise = false;
 
/**
* Booleen d'initalisation du conteneur d'image
*/
private boolean conteneurInitialise = false;
private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour revenir à la vue précédente, utilisez la roulette ou les boutons fléchés pour faire défiler les images </div>") ;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private ZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer à la vue
*/
public ZoomImageVue(ImageMediateur im) {
super("Zoom");
setId("x-view-zoom-panel");
// on associe le médiateur
iMediateur = im;
 
prev.setStylePrimaryName("x-view-zoom-button-p");
suiv.setStylePrimaryName("x-view-zoom-button-s");
 
// on crée une image qui gère le double clic et la roulette de la souris
image = new Image() {
 
public void onBrowserEvent(Event event) {
// lors du double clic
if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
 
// on notifie le médiateur
getIMediateur().doubleClicZoomImage();
}
 
// lors d'un déplacement de la roulette
if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
 
// on simule un clic sur le bouton précédent
if (event.getMouseWheelVelocityY() >= 1) {
prev.click();
}
 
// ou suivant
if (event.getMouseWheelVelocityY() <= -1) {
suiv.click();
}
}
}
};
 
this.setHeader(false);
 
imageConteneur = new Panel() ;
imageConteneur.setBorder(false);
 
imageConteneur.add(image);
imageConteneur.setId("x-view-zoom-img");
 
// il n'existe pas de méthode pour ajouter un listener pour le double
// clic sur une image
// alors on lui dit manuellement de capter l'évènement double clic
image.sinkEvents(Event.ONDBLCLICK);
image.sinkEvents(Event.ONMOUSEWHEEL);
 
// l'image de base est vide
image.setUrl("vide.jpg");
 
this.setLayout(new BorderLayout());
 
prev.setWidth("60px");
suiv.setWidth("60px");
 
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
configDragAndDrop() ;
 
// on ajoute les listeners
ajouterListeners();
tp.setDismissDelay(1750);
tp.applyTo(image.getElement()) ;
 
}
 
/**
* Méthode héritée de l'interface rafraichissable
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* le booleen qui dit si on doit répnadre l'évènement
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit une string
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise) {
String[] infos = (String[]) nouvelleDonnees;
// c'est l'url de l'image qu'on associe à la vue
if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
getImage().setUrl(infos[0]);
int x = Integer.parseInt(infos[1]);
int y = Integer.parseInt(infos[2]);
 
setTailleImage(x, y);
setIdImage(infos[3]) ;
 
verifierEtRetaillerImage();
}
} else {
// sinon on met une image vide
getImage().setUrl("vide.jpg");
}
}
 
/**
* Desactive visuellement le panneau et les boutons
*/
public void desactiverPanneau() {
getImage().setUrl("vide.jpeg");
prev.setEnabled(false);
suiv.setEnabled(false);
}
 
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau() {
prev.setEnabled(true);
suiv.setEnabled(true);
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
 
// gestion du clic sur le bouton précedent
prev.addClickListener(new ClickListener() {
 
// en cas de clic
public void onClick(Widget sender) {
// on notifie le médiateur
getIMediateur().clicBoutonZoomImage("prev");
}
 
});
 
// gestion du clic sur le bouton suivant
suiv.addClickListener(new ClickListener() {
 
// en cas de clic
public void onClick(Widget sender) {
// on notifie le médiateur
getIMediateur().clicBoutonZoomImage("suiv");
}
 
});
 
// gestion du redimensionnement
this.addListener(new PanelListenerAdapter() {
 
// lors d'un redimensionnement de l'application
 
public void onBodyResize(Panel panel, java.lang.String width,
java.lang.String height) {
// on vérifie et on retaille l'image
verifierEtRetaillerImage();
}
});
 
// gestion du redimensionnement lors de l'affichage du conteneur
imageConteneur.addListener(new PanelListenerAdapter() {
 
// avant de finir d'afficher
 
public void onAfterLayout(Container self) {
// on redimensionne
verifierEtRetaillerImage();
}
});
 
}
 
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
 
// on prend la taille originale de l'image
int originalX = getTailleImage()[0];
int originalY = getTailleImage()[1];
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).floatValue();
float fOriginalY = (new Float(originalY)).floatValue();
 
// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
float rapportTaille = fOriginalX / fOriginalY;
 
// la nouvelle taille est pour le moment égale à l'ancienne
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = imageConteneur.getWidth();
int tailleConteneurY = imageConteneur.getHeight();
 
// si celle-ci est égale à 0 (conteneur mal initialisé)
/*
* if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
* essaie de la calculer en fonction de la taille du parent et des
* frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
* this.getWidth() - prev.getOffsetWidth() * 2 ;
* }
*/
 
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
// si la longueur de l'image est la plus grande des deux
if (originalX > originalY) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = tailleConteneurX;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
/ rapportTaille);
} else {
// si la hauteur est la plus grande, on fait le même genre
// d'opération en prenant la hauteur comme référence
nouvelleTailleY = tailleConteneurY;
nouvelleTailleX = (int) Math.floor(nouvelleTailleY
* rapportTaille);
}
}
 
// on modifie enfin la taille de l'image pour qu'elle soit affichée
getImage().setSize("" + nouvelleTailleX + "px",
"" + nouvelleTailleY + "px");
}
public void configDragAndDrop()
{
 
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si on reçoit des données provenant d'une grille
if(data instanceof GridDragData)
{
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
return false ;
}
public String notifyOver(DragSource source, EventObject e, DragData data){
return "x-dd-drop-ok";
}
};
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur au conteneur de l'image
*
* @return le conteneur de l'image
*/
public Image getImage() {
return image;
}
/**
* Acesseurs pour l'identifiant de l'image
* @return l'id de l'image
*/
public String getIdImage()
{
return idImage ;
}
 
/**
* Accesseur pour le bouton précédent
*
* @return le bouton précédent
*/
public com.google.gwt.user.client.ui.Button getPrev() {
return prev;
}
 
/**
* Accesseur pour le bouton suivant
*
* @return le bouton suivant
*/
public com.google.gwt.user.client.ui.Button getSuiv() {
return suiv;
}
 
/**
* Setter pour la taille de l'image
*
* @param x
* la largeur en pixels
* @param y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y) {
imageHeight = y;
imageWidth = x;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
idImage = id ;
}
 
/**
* renvoie la taille originale de l'image
*
* @return un tableau de deux entiers contenant la largeur puis la hauteur
*/
public int[] getTailleImage() {
int[] taille = { imageHeight, imageWidth };
 
return taille;
}
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
 
return imageConteneur;
 
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java
New file
0,0 → 1,382
package org.tela_botanica.client.vues.image;
 
import java.util.Iterator;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
 
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.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.event.GridListenerAdapter;
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 {
 
/**
* 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 BarrePaginationVue pgBar = new BarrePaginationVue(iMediateur) ;
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;
/**
* Constructeur avec arguments
* @param im le médiateur à associer à la vue
*/
public MiniListeObservationVue(ImageMediateur im)
{
iMediateur = im ;
this.setId("x-view-mini-obs") ;
// on crée un store simple contenant un petit set de données et deux colonnes
store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, getObs());
ColumnConfig[] columns = {
new ColumnConfig("Numero", "id_obs", 50, true),
new ColumnConfig("Taxon", "plante", 145, true),
new ColumnConfig("Date", "date", 68, true),
new ColumnConfig("Lieu", "lieu", 145, true) } ;
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.addListener(new ContainerListenerAdapter() {
public void onRender(Component c) {
obtenirMiniListeObservations() ;
}
public void onAfterLayout(Container c)
{
obtenirMiniListeObservations() ;
}
}) ;
this.addGridListener(new GridListenerAdapter() {
 
public void onContextMenu(EventObject e) {
e.stopEvent() ;
MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ;
mlv.showAt(e.getXY()) ;
}
}) ;
}
/**
* 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 ;
String[][] listeObs = new String[data.size()][4] ;
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.getNomSaisi();
listeObs[i][2] = obs.getDate() ;
listeObs[i][3] = obs.getLocalite();
i++ ;
}
store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, listeObs);
store.load();
this.reconfigure(store, colModel) ;
}
else
{
addListener(new ContainerListenerAdapter() {
public void onShow(Component c)
{
obtenirMiniListeObservations() ;
}
public void onAfterLayout(Container c)
{
obtenirMiniListeObservations() ;
}
}) ;
}
}
deMasquerChargement() ;
}
private void obtenirMiniListeObservations()
{
iMediateur.obtenirMiniListeObservations(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 BarrePaginationVue getBarrePagination()
{
return pgBar ;
}*/
private void setModification(String mode)
{
if(mode.equals("true")) {
 
liaison = true ;
selecteurMode.removeClass("x-selec-consult") ;
selecteurMode.setCls("x-selec-liaison") ;
}
else
{
liaison = false ;
selecteurMode.removeClass("x-selec-liaison") ;
selecteurMode.setCls("x-selec-consult") ;
}
masquerChargement() ;
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 = sels[0].getAsString("id_obs") ;
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) {
this.setWidth("100%");
getView().setForceFit(true);
doLayout();
}
else {
Window.alert("null");
}
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/PanneauFiltresImagesVues.java
New file
0,0 → 1,145
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.layout.VerticalLayout;
 
/**
* Panneau contenant les filtres qu'on peut appliquer aux images
*
* @author aurelien
*
*/
public class PanneauFiltresImagesVues extends Panel {
 
/**
* Le médiateur associé
*/
private ImageMediateur iMediateur = null;
 
/**
* L'arbre pour la recherche par mots clés
*/
private ArbreMotsClesFiltreVue motsClesFiltres = null;
/**
* La barre de recherche par commentaires
*/
private BarreRechercheFiltreVue commFiltresVues = null;
 
/**
* Recherche par date
*/
private DateFiltreVue dateFiltreVues = null;
 
/**
* Recherche par contenu du tampon
*/
private SelectionFiltreVue selectionFiltreVue = null;
 
/**
* Bouton de validation
*/
private Button valider = null;
 
/**
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
*/
@SuppressWarnings("unused")
private PanneauFiltresImagesVues() {
super();
}
 
/**
* Constructeur avec arguments
*
* @param im
* le médiateur à associer
*/
public PanneauFiltresImagesVues(ImageMediateur im) {
super("Filtres");
iMediateur = im;
 
this.setCollapsible(true);
setLayout(new VerticalLayout());
 
commFiltresVues = new BarreRechercheFiltreVue(im);
add(commFiltresVues);
 
dateFiltreVues = new DateFiltreVue(im);
add(dateFiltreVues);
 
selectionFiltreVue = new SelectionFiltreVue(im);
add(selectionFiltreVue);
 
motsClesFiltres = new ArbreMotsClesFiltreVue(im);
add(motsClesFiltres);
 
Panel panelValidation = new Panel();
valider = new Button("Rechercher");
panelValidation.add(valider);
panelValidation.setBorder(false);
add(panelValidation);
 
valider.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
 
iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage());
 
}
 
});
}
 
/**
* Accesseur pour le filtre des mots clés
*
* @return le filtre des mots clés
*/
public ArbreMotsClesFiltreVue getMotsClesFiltre() {
return motsClesFiltres;
}
 
/**
* Accesseur pour le filtre par commentaire
*
* @return le filtre des commentaires
*/
public BarreRechercheFiltreVue getBarreRecherche() {
return commFiltresVues;
}
 
/**
* Renvoie un booléen indiquant si un des filtres a été modifié
*
* @return true sur un des filtres est modifié, false sinon
*/
public boolean renvoyerEtatFiltre() {
 
return (motsClesFiltres.renvoyerEtatFiltre()
|| commFiltresVues.renvoyerEtatFiltre()
|| dateFiltreVues.renvoyerEtatFiltre()
|| selectionFiltreVue.renvoyerEtatFiltre());
}
 
/**
* Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre",
* "valeur"
*
* @return un tableau contenant les noms et les valeurs à filtrer
*/
public String[][] renvoyerValeursAFiltrer() {
String[][] filtres = { motsClesFiltres.renvoyerValeursAFiltrer(),
commFiltresVues.renvoyerValeursAFiltrer(),
dateFiltreVues.renvoyerValeursAFiltrer(),
selectionFiltreVue.renvoyerValeursAFiltrer() };
return filtres;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/BarreRechercheFiltreVue.java
New file
0,0 → 1,161
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.form.TextField;
 
/**
* Fenêtre de recherche pour les mots clés, contenant un champ texte, et un
* bouton cliquable
*
* @author aurelien
*
*/
public class BarreRechercheFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
 
/**
* Barre de recherche
*
*/
private TextField champRecherche = null;
 
/**
* Booleen d'etat du filtre
*/
private boolean filtreModifie = false;
 
/**
* mot(s) à chercher
*/
private String motsAChercher = "";
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private BarreRechercheFiltreVue() {
super();
}
 
/**
* Constructeur avec médiateur
*
* @param im
*/
public BarreRechercheFiltreVue(ImageMediateur im) {
super();
iMediateur = im;
 
Label labelRecherche = new Label("Par commentaires :");
champRecherche = new TextField();
 
add(labelRecherche);
add(champRecherche);
 
setPaddings(5);
setBorder(false);
setAutoWidth(true);
setCollapsible(true);
 
ajouterListeners();
}
 
/**
* ajoute des listeners
*/
private void ajouterListeners() {
 
// gestion de la touche entrée
champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() {
 
public void onKey(int key, EventObject e) {
 
valider();
getIMediateur().obtenirPhotoGalerie(
getIMediateur().getFiltreCommentaires());
}
 
});
}
 
/**
* Fonction héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
filtreModifie = false;
 
}
 
/**
* renvoie l'état du filtre (modifié ou non)
*
* @return l'état du filtre
*/
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
/**
* Renvoie le nom du filtre
*
* @return le nom du filtre
*/
public String renvoyerNomFiltre() {
 
return "Recherche Commentaires";
}
 
/**
* Renvoie un tableau contenant le nom du champ à filtrer et la valeur
*
* @return un tableau contenant le nom du champ à filtrer et sa valeur
*/
public String[] renvoyerValeursAFiltrer() {
 
valider() ;
String[] valeurFiltre = { "ci_meta_comment", motsAChercher };
return valeurFiltre;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Effectue quelque opérations dans la classe et envoie une requête de
* données au médiateur
*/
public void valider() {
filtreModifie = true;
motsAChercher = champRecherche.getText();
}
 
/**
* Affiche la fenetre
*/
public void afficherFiltre() {
 
champRecherche.setValue(motsAChercher);
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/MenuFiltreVue.java
New file
0,0 → 1,96
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
 
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
 
public class MenuFiltreVue extends Menu {
 
/**
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur;
 
/**
* Item pour la recherche par mots clés
*/
private Item chercherImage = null;
 
/**
* Item pour la recherche sur les commentaires
*/
private Item chercherCommentaire = null;
 
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private MenuFiltreVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public MenuFiltreVue(ImageMediateur im) {
super();
 
iMediateur = im;
 
// on construit le menu
chercherImage = new Item("Filtrer par les mots clés");
chercherCommentaire = new Item("Filtrer par les commentaires");
addItem(chercherImage);
addItem(chercherCommentaire);
 
// on ajoute les listeners
ajouterListeners();
}
 
/**
* Ajoute les listeners pour la gestions des évènements
*/
private void ajouterListeners() {
this.addListener(new MenuListenerAdapter() {
 
// gestion du clic sur un item
 
public void onItemClick(BaseItem item, EventObject e) {
 
// si c'est la recherche par mots clé
if (item.equals(chercherImage)) {
// on notifie le médiateur
// getIMediateur().afficherFiltreMotsCles() ;
}
 
// si c'est la recherche par commentaires
if (item.equals(chercherCommentaire)) {
// on notifie le médiateur
// getIMediateur().afficherFiltreCommentaires() ;
}
 
// enfin, on cache le menu
hide();
 
}
 
});
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java
New file
0,0 → 1,100
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.vues.MenuAideVue;
 
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarMenuButton;
 
/**
* Barre d'outils contenant le menu de gestion des images (accessible aussi par
* un clic droit dans la galerie) et d'autres menus et boutons utiles
*
* @author aurelien
*
*/
public class BarreOutilsVue extends Toolbar {
 
/**
* Un bouton qui sert à déployer le menu
*/
ToolbarMenuButton images = null;
/**
* Un bouton qui sert à déployer le menu
*/
ToolbarMenuButton utilisateur = null;
/**
* Bouton pour déployer le menu d'aide
*/
ToolbarMenuButton aide = null ;
 
/**
* Le médiateur associé à la toolbar
*/
ImageMediateur iMediateur = null;
/**
* Le menu de gestion des images
*/
MenuImageVue imageMenu = null;
 
/**
* Le menu de gestion des filtres
*/
MenuFiltreVue filtreMenu = null;
 
/**
* Le menu de gestion utilisateur
*/
MenuIdVue idMenu = null;
/**
* Menu de gestion d'aide
*/
MenuAideVue aideMenu = null ;
 
/**
* Constructeur sans argument (ne doit pas être utilisé donc privé)
*/
@SuppressWarnings("unused")
private BarreOutilsVue() {
super();
}
 
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer à la vue
*/
public BarreOutilsVue(ImageMediateur im) {
 
super();
 
iMediateur = im;
 
imageMenu = new MenuImageVue(im);
filtreMenu = new MenuFiltreVue(im);
//aideMenu = new MenuAideVue(im);
images = new ToolbarMenuButton("Fichiers", imageMenu);
//aide = new ToolbarMenuButton("Aide", aideMenu);
 
this.addButton(images);
//this.addButton(aide);
}
 
/**
* @return the images
*/
public ToolbarMenuButton getImages() {
return images;
}
 
/**
* @return the iMediateur
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/GalerieImageVue.java
New file
0,0 → 1,480
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import org.tela_botanica.client.vues.BarrePaginationVue;
 
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.ui.HTML;
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.XTemplate;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.util.Format;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.DataView;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListener;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.DataViewListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
 
/**
* Galerie d'images miniatures Avec barre de pagination
*
* @author aurelien
*/
public class GalerieImageVue extends Panel implements Rafraichissable,
VueListable, ListePaginable {
 
/**
* instance du médiateur
*/
private ImageMediateur iMediateur = null;
/**
* Dataview, littéralement "vue de données" qui permet de définir la manière
* d'afficher les données
*/
private DataView dView = null;
/**
* Dataview, littéralement "vue de données" qui permet de définir la manière
* d'afficher les données
*/
private Store st = null;
/**
* Barre de pagination gérant l'affichage d'un nombre donné d'élements par
* page et la navigation entre eux
*/
private BarrePaginationVue pt = null;
/**
* Booleen indiquant si la galerie est instanciée ou pas
*/
private boolean estInstancie = false;
private boolean garderRatio = false;
private int tailleOr = 100 ;
boolean lienUploadInitialise = false ;
HTML videPanel = null ;
 
 
/**
* Constructeur sans argument, privé car ne doit pas être utilisé
*/
@SuppressWarnings("unused")
private GalerieImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur avec lequel la vue va communiquer
*/
public GalerieImageVue(ImageMediateur im) {
super("Galerie");
iMediateur = im;
// on ajoute des listeners au composant tout entier
this.addListener(new ContainerListenerAdapter() {
 
// pour gagner du temps on n'instancie la vue en elle même que lors
// du premier affichage (lazy rendering)
 
public void onShow(Component component) {
 
if (!estInstancie) {
initialiser();
}
}
});
AjouterListenersLiens();
 
// et on ajoute la tool bar
pt = new BarrePaginationVue(this);
pt.setLabelElement("Images");
pt.setTaillePageParDefaut(50);
this.setBottomToolbar(pt);
 
}
 
/**
* Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la
* vue de données
*/
public void ajouterListenersDataView() {
 
// ajout de listeners pour la gestion de la selection
// dans la galerie
dView.addListener(new DataViewListenerAdapter() {
 
// gestion du clic sur une image
 
public void onClick(DataView source, int index, Element node,
EventObject e) {
// on en notifie le médiateur
getIMediateur().clicGalerieImage(index, node, e);
 
}
 
// gestion du clic droit
 
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) {
 
// 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");
}
}
});
}
 
/**
* 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;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("num_image");
}
 
return id_selection;
}
 
/**
* Accesseur pour le médiateur
*
* @return le médiateur associé à la vue
*/
public ImageMediateur getIMediateur() {
return iMediateur;
}
 
/**
* Accesseur pour le store
*
* @return le store associé à la vue
*/
public Store getSt() {
return st;
}
 
/**
* Accesseur pour la toolbar
*
* @return la toolbar associée à la vue
*/
public BarrePaginationVue getToolBarVue() {
return pt;
}
 
/**
* Fonction d'initialisation du contenu (appelée lors du premier affichage
* de la liste)
*/
public void initialiser() {
 
// Preparation de la dataview et du template
// le template va créer une div contenant une image
// pour chacune des photos
final XTemplate template = new XTemplate(
new String[] {
"<tpl for='.'>",
"<div class='thumb-wrap' id='{num_image}'>",
"<div class='thumb'><img src='{url_image_M}' width='{taille_x_s} px' height='{taille_y_s} px' 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
// cree precedemment
dView = new DataView("div.thumb-wrap") {
 
public void prepareData(Data data) {
data.setProperty("shortName", Format.ellipsis(data
.getProperty("num_image"), 15));
int[] XY = {data.getPropertyAsInt("taille_x") ,data.getPropertyAsInt("taille_y")} ;
int[] XYresize ;
if(garderRatio) {
XYresize = calculerDimensions(XY);
}
else {
XYresize = new int[2] ;
XYresize[0] = XYresize[1] = tailleOr ;
}
data.setProperty("taille_x_s", XYresize[0]);
data.setProperty("taille_y_s", XYresize[1]);
}
};
dView.setTpl(template);
 
// parametre d'affichage de la dataview
this.setAutoScroll(true);
dView.setAutoHeight(true);
dView.setMultiSelect(true);
dView.setOverCls("x-view-over");
dView.setEmptyText("");
 
// creation du store
FieldDef defNumImage = new IntegerFieldDef("num_image");
FieldDef defDatImage = new StringFieldDef("dat_image");
FieldDef defLieImage = new StringFieldDef("lie_image");
FieldDef defAppImage = new StringFieldDef("app_image");
FieldDef defUrlImageS = new StringFieldDef("url_image_S");
FieldDef defUrlImageM = new StringFieldDef("url_image_M");
FieldDef defUrlImage = new StringFieldDef("url_image");
FieldDef defTailleX = new IntegerFieldDef("taille_x");
FieldDef defTailleY = new IntegerFieldDef("taille_y");
FieldDef[] defTab = { defNumImage, defDatImage, defLieImage,
defAppImage, defUrlImageS, defUrlImageM, defUrlImage,defTailleX,defTailleY};
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
dView.setStore(st);
 
this.getDView().setLoadingText("chargement");
 
this.add(dView);
dView.hide();
videPanel = new HTML("<div class=\"avertissement\" >Aucune image à afficher. <br/> <a id=\"lienUploadMultiple\" href=\"#\" > Cliquez ici pour ajouter un dossier entier ou plusieurs fichiers </a> (nécessite Java) <br/> " +
" <a id=\"lienUploadSimple\" href=\"#\" > Cliquez ici pour ajouter un fichier à la fois </a> <br/> " +
" Pour ajouter des images plus tard, allez dans le menu Fichier -> Ajouter des images </div>");
this.add(videPanel);
// ajouts de la gestion des evenements pour la dataview
configDragAndDrop() ;
ajouterListenersDataView();
estInstancie = true ;
}
public void configDragAndDrop()
{
// on fabrique la nouvelle configuration
// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
DropTargetConfig dtc = new DropTargetConfig();
dtc.setdDdGroup("DragGroupName");
 
//La drop target permet de gérer l'évenement onDrop sur l'élement courant
@SuppressWarnings("unused")
DropTarget tg = new DropTarget(this, dtc)
{
public boolean notifyDrop(DragSource source, EventObject e, DragData data){
// si les données proviennent d'une grille
if(data instanceof GridDragData)
{
// on appelle le médiateur
return iMediateur.lierObsDD(source, e, data,getId()) ;
}
return false ;
}
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 repandreRafraichissement) {
 
// si l'objet reçu est un store
if (nouvelleDonnees instanceof Store) {
 
st = (Store) nouvelleDonnees;
if(st.getCount() != 0) {
// on le charge
st.load();
if(videPanel.isVisible()) {
videPanel.setVisible(false) ;
}
if(!dView.isVisible()) {
dView.setVisible(true);
}
// on l'affecte à la vue
dView.setStore(st);
// et on rafrachit la vue
dView.refresh();
}
else
{
st.removeAll();
st.load();
dView.setStore(st);
if(dView.isVisible()) {
dView.hide() ;
}
if(!videPanel.isVisible()) {
videPanel.setVisible(true);
AjouterListenersLiens();
}
}
}
 
// si le composant doit répandre le rafraichissement
if (repandreRafraichissement) {
// il en notifie le médiateur en lui donnant une copie des données
// et en notifiant qu'il en est l'expéditeur
getIMediateur().synchroniserDonneesZoomListeGalerie(
nouvelleDonnees, this);
}
}
 
/**
* Méthode héritée de l'interface VueListable Sélectionne les images dans la
* galerie suivant les identifiants donnés en paramètres
*
* @param ids
* les identifiants des images à sélectionner
*/
public void selectionnerImages(int[] ids) {
 
getDView().select(ids);
 
}
 
public void changerNumeroPage(int pageCourante) {
iMediateur.changerNumeroPage(pageCourante) ;
}
 
public void changerTaillePage(int nouvelleTaillePage) {
iMediateur.changerTaillePage(nouvelleTaillePage) ;
}
public int[] calculerDimensions(int[] tailleXY) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = this.tailleOr ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
return res;
}
private void AjouterListenersLiens() {
 
addListener(new PanelListenerAdapter() {
public void onAfterLayout(Container c) {
ExtElement uploadS = Ext.get("lienUploadSimple");
uploadS.removeAllListeners();
uploadS.addListener("click", new EventCallback() {
public void execute(EventObject e) {
getIMediateur().uploaderImages(false);
}
}) ;
ExtElement uploadM = Ext.get("lienUploadMultiple");
uploadM.removeAllListeners();
uploadM.addListener("click", new EventCallback() {
public void execute(EventObject e) {
getIMediateur().uploaderImages(true);
}
});
}
 
});
}
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/image/SelectionFiltreVue.java
New file
0,0 → 1,89
package org.tela_botanica.client.vues.image;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Filtrable;
 
import com.google.gwt.user.client.ui.Label;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.form.Checkbox;
 
public class SelectionFiltreVue extends Panel implements Filtrable {
 
private ImageMediateur iMediateur = null;
 
private boolean filtreModifie = false;
 
private Checkbox check = null;
@SuppressWarnings("unused")
private SelectionFiltreVue()
{
super() ;
}
 
public SelectionFiltreVue(ImageMediateur im) {
 
super();
iMediateur = im ;
Label labelRecherche = new Label(
"Afficher uniquement les images dans le tampon :");
add(labelRecherche);
setBorder(false);
setPaddings(5);
 
/*
* combo = new ComboBox() ; String tout = "toutes les images "; String
* selection = "dans le tampon seulement" ; Object[][] data = new
* Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ;
* data[1][1] = selection ;
* // creation du store qui les contient FieldDef defIdChoix = new
* IntegerFieldDef("id_choix"); FieldDef defNomChoix = new
* StringFieldDef("nom_choix");
*
* FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new
* RecordDef(defTab) ;
*
* final MemoryProxy dataProxy = new MemoryProxy(data); final
* ArrayReader reader = new ArrayReader(rd);
*
* st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ;
* combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL);
* combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ;
* add(combo) ;
*/
 
check = new Checkbox();
check.setChecked(false) ;
add(check);
 
}
 
public boolean renvoyerEtatFiltre() {
 
return filtreModifie;
}
 
public String renvoyerNomFiltre() {
 
return "Filtre par tampon";
}
 
public String[] renvoyerValeursAFiltrer() {
 
if (check.getValue()) {
String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() };
return val;
}
String[] val = { "ci_id_tampon", "" };
return val;
}
 
public void valider() {
 
filtreModifie = true;
 
}
 
}
Property changes:
Added: svn:mergeinfo
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
2,7 → 2,6
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
10,16 → 9,13
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**