Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 154 → Rev 155

/trunk/src/org/tela_botanica/client/vues/MiniListeObservationVue.java
7,6 → 7,7
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
 
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.MouseListenerAdapter;
import com.gwtext.client.data.Record;
15,11 → 16,15
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.event.ComponentListenerAdapter;
import com.gwtext.client.widgets.event.ContainerListener;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListener;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
29,6 → 34,7
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.event.GridListener;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.widgets.map.OpenLayersMap;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
83,15 → 89,17
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"}, getObs());
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("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
122,6 → 130,8
bt = new Toolbar() ;
bt.addField(selecteurMode) ;
//this.setAutoExpandColumn("plante");
setTopToolbar(bt) ;
selecteurMode.addListener(new ComboBoxListenerAdapter() {
159,8 → 169,7
}
}) ;
}) ;
}
/**
223,7 → 232,7
if(this.getView() != null)
{
ListeObservation data = (ListeObservation)nouvelleDonnees ;
String[][] listeObs = new String[data.size()][3] ;
String[][] listeObs = new String[data.size()][4] ;
int i = 0 ;
for (Iterator it = data.keySet().iterator(); it.hasNext();)
234,11 → 243,12
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"}, listeObs);
store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, listeObs);
store.load();
this.reconfigure(store, colModel) ;
}
358,6 → 368,15
}
 
public void redimensionner() {
if(getView() != null) {
this.setWidth("100%");
getView().setForceFit(true);
doLayout();
}
else {
Window.alert("null");
}
}
}
/trunk/src/org/tela_botanica/client/vues/PanneauMetadonneesVue.java
72,6 → 72,11
* L'onglet des mots clés
*/
private ArbreMotsClesVue panneauMotsCles = null;
/**
* l'onglet des observations
*/
private Panel panneauMiniListeObservation = null;
 
/**
* Le champ commentaire
155,10 → 160,9
 
noteVue = new BarreNotationVue(im, 5);
Panel panneauMiniListeObservation = new Panel("Observations") ;
panneauMiniListeObservation = new Panel("Observations") ;
panneauMiniListeObservation.setLayout(new FitLayout()) ;
panneauMiniListeObservation.setHeight(800) ;
panneauMiniListeObservation.setAutoWidth(true) ;
miniListeObservation = new MiniListeObservationVue(im) ;
panneauMiniListeObservation.add(miniListeObservation) ;
 
377,4 → 381,14
{
return miniListeObservation ;
}
 
public void redimensionner() {
if(panneauMiniListeObservation.isCreated() && panneauMiniListeObservation.isVisible()) {
panneauMiniListeObservation.doLayout();
//panneauMiniListeObservation.show();
miniListeObservation.redimensionner();
}
}
}
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesFiltreVue.java
3,20 → 3,31
import org.tela_botanica.client.image.ImageMediateur;
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.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;
import com.gwtext.client.data.NodeTraversalCallback;
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;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
32,7 → 43,13
* Le médiateur associé à la vue
*/
private ImageMediateur iMediateur = null;
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
/**
* Les mots clés en cours
*/
private String motsClesEncours = "";
40,17 → 57,28
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreMotsCles = null;
private static TreePanel arbreMotsCles = null;
 
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
private boolean arbreInitialise = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
/**
* prefixe pour générer des ids adaptées
*/
private String prefixe = "_filtre" ;
private final String prefixeImg = "_images" ;
private final String prefixeObs = "_obs" ;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
70,21 → 98,63
 
// on crée le panel
super();
// this.setLayout(new VerticalLayout());
iMediateur = im;
this.prefixe += prefixeImg;
Label labelRecherche = new Label("Mots clés :");
add(labelRecherche);
initialiserPanel();
}
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesFiltreVue(ObservationMediateur om) {
 
// on crée le panel
super();
oMediateur = om;
this.prefixe += prefixeObs;
initialiserPanel();
this.setLayout(new RowLayout());
 
}
public void initialiserPanel() {
// on crée le conteneur de l'arbre
Label labelRecherche = new Label("Mots clés :");
arbreMotsCles = new TreePanel();
arbreMotsCles.setId("x-view-tree-filter");
arbreMotsCles.setId("x-view-tree-filter"+prefixe);
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine_filtre");
String[] usObject = { "Mots clés", "racine_filtre" };
root.setId("racine"+prefixe);
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
 
public void onClick(Node node, EventObject e) {
if(!arbreInitialise) {
expand();
}
}
 
public void onExpand(Node node) {
if(!arbreInitialise) {
obtenirArbreMotsCles();
arbreInitialise = true;
}
}
 
});
this.setPaddings(5);
 
this.setBorder(false);
91,8 → 161,6
this.setCollapsible(true);
this.setAutoWidth(true);
 
add(labelRecherche);
 
// on ajoute les listeners
ajouterListenersPanel();
estInstancie = false;
115,30 → 183,29
arbreMotsCles.setAutoScroll(true);
arbreMotsCles.setBorder(false);
 
if(estInstancie)
{
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine_filtre");
String[] usObject = { "Mots clés", "racine_filtre" };
root.setUserObject(usObject);
arbreMotsCles.setRootNode(root);
// on met en forme le layout
((Panel) component).add(arbreMotsCles,new RowLayoutData("80%"));
if(iMediateur == null) {
Panel p = new Panel();
p.setBorder(false);
Button valider = new Button("Rechercher") ;
valider.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
getOMediateur().obtenirNombreObservation();
}
});
p.add(valider,new RowLayoutData());
add(p);
}
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
 
// on met en forme le layout
((Panel) component).add(arbreMotsCles);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
// enfin on considère le composant comme instancié
estInstancie = true;
 
//obtenirArbreMotsCles();
}
 
});
}
 
158,7 → 225,7
// si on a reçu un arbre
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree) nouvelleDonnees;
 
// on vide tous les noeuds de l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
176,11 → 243,15
estInstancie = true;
}
if(!arbreInitialise) {
arbreInitialise = true;
}
arbreMotsCles.setRootNode(arbreMotsCles.getRootNode());
 
// l'état du filtre est réinitialisé
filtreModifie = false;
show() ;
doLayout() ;
}
 
if (nouvelleDonnees instanceof TreeNode) {
187,13 → 258,13
TreeNode nd = (TreeNode) nouvelleDonnees;
 
// si le noeud n'existe pas déjà c'est un ajout
if (arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre") == null) {
if (arbreMotsCles.getTree().getNodeById(nd.getId() +prefixe) == null) {
// donc on ne fait rien de spécial
}
// si le noeud existe déjà c'est un déplacement
else {
// alors on supprime d'abord le noeud concerné
arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre")
arbreMotsCles.getTree().getNodeById(nd.getId() +prefixe)
.remove();
}
 
201,11 → 272,11
Node ndPereOriginal = nd.getParentNode();
 
String idPereFiltre = ndPereOriginal.getId() + "_filtre";
String idPereFiltre = ndPereOriginal.getId() +prefixe;
 
String[] usObj = (String[]) nd.getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1] + "_filtre");
child.setId(usObj[1] +prefixe);
child.setChecked(false);
child.setUserObject(usObj);
arbreMotsCles.getNodeById(idPereFiltre).appendChild(child);
217,7 → 288,7
 
// si on reçoit une string
if (nouvelleDonnees instanceof String) {
String idSupp = (String) nouvelleDonnees + "_filtre";
String idSupp = (String) nouvelleDonnees +prefixe;
// c'est une suppression et si le noeud existe bien
if (arbreMotsCles.getTree().getNodeById(idSupp) != null) {
// on le supprime
236,6 → 307,10
public ImageMediateur getIMediateur() {
return iMediateur;
}
public ObservationMediateur getOMediateur() {
return oMediateur ;
}
 
/**
* Accesseur pour le panneau contenant l'arbre
262,9 → 337,17
public String[] renvoyerValeursAFiltrer() {
 
valider();
String[] valeursFiltrees = new String[2] ;
valeursFiltrees[1] = motsClesEncours;
if(iMediateur != null) {
valeursFiltrees[0] = "ci_meta_mots_cles";
}
else
{
valeursFiltrees[0] = "mots_cles";
}
 
String[] valeursFiltrees = { "ci_meta_mots_cles", motsClesEncours };
 
return valeursFiltrees;
}
 
285,7 → 368,7
 
String[] usObj = (String[]) ndNodeFils[i].getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1] + "_filtre");
child.setId(usObj[1] +prefixe);
child.setChecked(false);
child.setUserObject(usObj);
ndPereCopie.appendChild(child);
305,6 → 388,27
 
return filtreModifie;
}
public void mettreAJourMotsCles(String valeur, String id) {
if(getIMediateur() != null) {
getIMediateur().mettreAjourMotsClesId(valeur,
id);
}
else
{
getOMediateur().mettreAjourMotsClesId(valeur, id);
}
}
public void obtenirArbreMotsCles() {
if(getIMediateur() != null) {
getIMediateur().obtenirArbreMotsCles(this);
}
else
{
getOMediateur().obtenirArbreMotsCles(this);
}
}
 
public void valider() {
if (estInstancie) {
323,8 → 427,7
node.getId());
 
String[] usObject = (String[]) tn.getUserObject();
getIMediateur().mettreAjourMotsClesId(usObject[0],
usObject[1]);
mettreAJourMotsCles(usObject[0], usObject[1]);
 
if (tn.getUI().isChecked()) {
// et les concatène à la string des mots clés en
342,4 → 445,42
}
}
 
public void raz() {
// on vide tous les noeuds de l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
arbreInitialise = false ;
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine"+prefixe);
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
root.setExpandable(true);
arbreMotsCles.setRootNode(root);
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
 
public void onClick(Node node, EventObject e) {
if(!arbreInitialise) {
expand();
}
}
 
public void onExpand(Node node) {
if(!arbreInitialise) {
obtenirArbreMotsCles();
arbreInitialise = true;
}
}
});
}
 
}
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesObsFiltreVue.java
New file
0,0 → 1,369
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
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.core.client.JavaScriptObject;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Label;
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.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.menu.Menu;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
 
/**
* fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
* cliquable
*
* @author aurelien
*
*/
public class ArbreMotsClesObsFiltreVue extends Panel implements Rafraichissable,
Filtrable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur oMediateur = null;
/**
* Les mots clés en cours
*/
private String motsClesEncours = "";
 
/**
* Le treepanel qui affiche l'arbre
*/
private TreePanel arbreMotsCles = null;
 
/**
* booléen d'initialisation
*/
private boolean estInstancie = false;
 
/**
* booléen d'etat
*/
private boolean filtreModifie = false;
 
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
@SuppressWarnings("unused")
private ArbreMotsClesObsFiltreVue() {
super();
}
/**
* Constructeur avec paramètres
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesObsFiltreVue(ObservationMediateur om) {
 
// on crée le panel
super();
oMediateur = om;
Button valider = new Button("Rechercher") ;
valider.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
getOMediateur().obtenirListeObservation();
}
});
add(valider);
initialiserPanel();
 
}
public void initialiserPanel() {
// on crée le conteneur de l'arbre
Label labelRecherche = new Label("Mots clés :");
arbreMotsCles = new TreePanel();
arbreMotsCles.setId("x-view-tree-filter");
 
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine_filtre");
String[] usObject = { "Mots clés", "racine_filtre" };
root.setUserObject(usObject);
arbreMotsCles.setRootNode(root);
this.setPaddings(5);
 
this.setBorder(false);
this.setCollapsible(true);
this.setAutoWidth(true);
 
add(labelRecherche);
 
// 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
arbreMotsCles.setEnableDD(false);
arbreMotsCles.setAutoWidth(false);
arbreMotsCles.setAutoScroll(true);
arbreMotsCles.setBorder(false);
 
if(estInstancie)
{
obtenirArbreMotsCles();
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine_filtre");
String[] usObject = { "Mots clés", "racine_filtre" };
root.setUserObject(usObject);
arbreMotsCles.setRootNode(root);
}
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
 
// on met en forme le layout
((Panel) component).add(arbreMotsCles);
 
// on ajoute les listeners d'évenements
ajouterListeners();
 
}
 
});
}
 
/**
* ajoute les listeners pour les boutons et le cochage des mots clés
*/
private void ajouterListeners() {
}
 
/**
* Méthode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
 
// si on a reçu un arbre
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree) nouvelleDonnees;
// on vide tous les noeuds de l'ancien arbre
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
for (int i = 0; i < rootChild.length; i++) {
rootChild[i].remove();
}
 
// et on recopie le nouvel arbre
copierFilsNoeud(nouvelArbre.getRootNode(), arbreMotsCles
.getRootNode());
 
// si l'arbre n'était pas encore considéré comme instancié
if (!estInstancie) {
// on signale que oui
estInstancie = true;
}
arbreMotsCles.setRootNode(arbreMotsCles.getRootNode());
 
// l'état du filtre est réinitialisé
filtreModifie = false;
doLayout() ;
}
 
if (nouvelleDonnees instanceof TreeNode) {
TreeNode nd = (TreeNode) nouvelleDonnees;
 
// si le noeud n'existe pas déjà c'est un ajout
if (arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre") == null) {
// donc on ne fait rien de spécial
}
// si le noeud existe déjà c'est un déplacement
else {
// alors on supprime d'abord le noeud concerné
arbreMotsCles.getTree().getNodeById(nd.getId() + "_filtre")
.remove();
}
 
// on chercher le père du nouveau noeud
Node ndPereOriginal = nd.getParentNode();
 
String idPereFiltre = ndPereOriginal.getId() + "_filtre";
 
String[] usObj = (String[]) nd.getUserObject();
TreeNode child = new TreeNode(usObj[0]);
child.setId(usObj[1] + "_filtre");
child.setChecked(false);
child.setUserObject(usObj);
arbreMotsCles.getNodeById(idPereFiltre).appendChild(child);
 
// et on ajoute le nouveau noeud à son père
copierFilsNoeud(nd, child);
this.doLayout();
}
 
// si on reçoit une string
if (nouvelleDonnees instanceof String) {
String idSupp = (String) nouvelleDonnees + "_filtre";
// c'est une suppression et si le noeud existe bien
if (arbreMotsCles.getTree().getNodeById(idSupp) != null) {
// on le supprime
arbreMotsCles.getTree().getNodeById(idSupp).remove();
}
}
 
}
public ObservationMediateur getOMediateur() {
return oMediateur ;
}
 
/**
* Accesseur pour le panneau contenant l'arbre
*
* @return le panneau de l'arbre des mots clés
*/
public TreePanel getArbreMotsCles() {
return arbreMotsCles;
}
 
/**
* Méthode héritée de Filtrable renvoie le nom du filtre
*/
public String renvoyerNomFiltre() {
 
return "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() {
 
valider();
 
String[] valeursFiltrees = { "ci_meta_mots_cles", motsClesEncours };
 
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.setId(usObj[1] + "_filtre");
child.setChecked(false);
child.setUserObject(usObj);
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 mettreAJourMotsCles(String valeur, String id) {
 
getOMediateur().mettreAjourMotsClesId(valeur, id);
}
public void obtenirArbreMotsCles() {
 
getOMediateur().obtenirArbreMotsCles(this);
}
 
public void valider() {
if (estInstancie) {
// 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();
mettreAJourMotsCles(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;
}
 
});
 
// on suppose que le filtre a change
filtreModifie = true;
}
}
 
}
 
/trunk/src/org/tela_botanica/client/vues/PanneauFiltresObservationVues.java
42,8 → 42,10
*/
private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null;
private ArbreMotsClesFiltreVue arbreMotsClesFiltreVue = null ;
 
/**
* Construcuteur sans argument (privé car on ne doit pas l'utiliser)
81,6 → 83,15
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();
}
 
/**
97,6 → 108,10
return arbreDateObservationFiltreVue;
}
public ArbreMotsClesFiltreVue getArbreMotsClesFiltreVue() {
return arbreMotsClesFiltreVue;
}
/**
* Renvoie un booléen indiquant si un des filtres a été modifié
*
117,6 → 132,7
public String[][] renvoyerValeursAFiltrer() {
String[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(),
arbreMotsClesFiltreVue.renvoyerValeursAFiltrer()
};
return filtres;
/trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java
436,16 → 436,15
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
ExtElement masked = Ext.get(getId()) ;
if (masked!=null) {
 
if (masked!=null) {
if(masked.isMasked())
{
masked.unmask() ;
}
if(masked.isMasked())
{
masked.unmask() ;
}
}
}
 
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java
2,6 → 2,7
 
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;
61,7 → 62,7
* (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;
private String[] motsClesEnAttente = new String[0];
/**
* Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
* noeud
113,7 → 114,7
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
arbreMotsCles.setRootNode(root);
arbreMotsCles.setRootVisible(false);
arbreMotsCles.setRootVisible(true);
arbreMotsCles.setBorder(false);
arbreMotsCles.setWidth(500);
 
432,18 → 433,10
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
// si on a reçu un arbre
if (nouvelleDonnees instanceof Tree) {
Tree nouvelArbre = (Tree) nouvelleDonnees;
if(nouvelleDonnees instanceof Tree) {
 
if (nouvelArbre.getRootNode().getChildNodes().length <= 0) {
// on crée une racine pour l'arbre
TreeNode root = new TreeNode("Tags");
root.setId("racine");
String[] usObject = { "Mots clés", "racine" };
root.setUserObject(usObject);
}
Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
// on prend sa racine et on l'attache à l'arbre des mots clés
Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
452,26 → 445,8
rootChild[i].remove();
}
getArbreMotsCles().getRootNode().appendChild(
nouvelArbre.getRootNode());
getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
 
public boolean execute(Node node) {
String usObject[] = (String[]) node
.getUserObject();
String nodeId = usObject[1];
getArbreMotsCles().getNodeById(nodeId)
.getUI().toggleCheck(false);
return false;
}
}) ;
 
// si l'arbre n'était pas encore considéré comme instancié
if (!arbreCharge) {
// on signale que oui
484,6 → 459,10
// 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
502,6 → 481,8
// attente
else {
motsClesEnAttente = (String[]) nouvelleDonnees;
Window.alert("des mots clés en attente : "+motsClesEnAttente[0]);
}
}
}
509,5 → 490,34
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]);
child.setChecked(false);
child.setUserObject(usObj);
ndPereCopie.appendChild(child);
 
if (!ndNodeFils[i].isLeaf()) {
copierFilsNoeud(ndNodeFils[i], child);
}
 
}
}
}
}
/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesObsVue.java
New file
0,0 → 1,529
package org.tela_botanica.client.vues;
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.core.client.GWT;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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.data.event.NodeListener;
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.TreeNodeListener;
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
public class ArbreMotsClesObsVue 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 ArbreMotsClesObsVue() {
super();
}
 
/**
* Constructeur avec paramètre
*
* @param im
* le médiateur à associer
*/
public ArbreMotsClesObsVue(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);
}
 
}
}
}
}