/branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
---|
New file |
0,0 → 1,764 |
package org.tela_botanica.client.vues.observation.filtres; |
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.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.dd.DragData; |
import com.gwtext.client.dd.DragDrop; |
import com.gwtext.client.dd.DropTargetConfig; |
import com.gwtext.client.widgets.Button; |
import com.gwtext.client.widgets.Component; |
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.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.widgets.tree.DropNodeCallback; |
import com.gwtext.client.widgets.tree.MultiSelectionModel; |
import com.gwtext.client.widgets.tree.TreeDragData; |
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, Filtrable { |
/** |
* 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 ajouterMotCle = 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 nécessaire pour l'affichage |
* |
*/ |
private boolean estInstancie = false; |
/** |
* Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
*/ |
private boolean motsCleInitialises; |
private Component livue = null; |
MultiSelectionModel msModel = null; |
/** |
* 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("Projets"); |
this.setLayout(new VerticalLayout()); |
oMediateur = om; |
setBorder(false); |
setCollapsible(true); |
setTitleCollapse(true); |
setAutoScroll(true); |
// on ajoute les listeners |
ajouterListenersPanel(); |
} |
/** |
* 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 |
@Override |
public void onRender(Component component) { |
livue = oMediateur.getListeObservation(); |
// 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"); |
msModel = new MultiSelectionModel(); |
arbreMotsCles.setSelectionModel(msModel); |
// on crée une racine pour l'arbre |
TreeNode root = new TreeNode("Projets"); |
root.setId("racine_obs"); |
String[] usObject = { "Projets", "racine_obs" }; |
root.setUserObject(usObject); |
root.setExpandable(true); |
arbreMotsCles.setRootNode(root); |
// on crée l'éditeur pour l'arbre |
tfEdit = new TextField(); |
te = new TreeEditor(arbreMotsCles, tfEdit); |
ajouterMotCle = new Button("Ajouter un projet"); |
arbreMotsCles.add(te); |
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
@Override |
public void onClick(Node node, EventObject e) { |
if(!arbreCharge) { |
expand(); |
} |
} |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) { |
obtenirArbreMotsCles(); |
arbreCharge = true; |
} |
} |
}); |
// on interdit le drag and drop dans l'arbre |
arbreMotsCles.setRootVisible(true); |
arbreMotsCles.setBorder(false); |
// on met en forme le layout |
add(arbreMotsCles); |
add(ajouterMotCle); |
// enfin on considère le composant comme instancié |
estInstancie = true; |
configDragAndDrop(); |
// on ajoute les listeners d'évenements |
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 |
@Override |
public void onClick(TreeNode node, EventObject e) { |
e.stopEvent(); |
boolean multi = false; |
if(e.hasModifier()) { |
multi = true; |
} |
gererClicNoeud(node,multi); |
} |
// gestion du clic droit sur un noeud |
@Override |
public void onContextMenu(TreeNode node, EventObject e) { |
e.stopEvent(); |
montrerContextMenuArbre(node, e, getTe()); |
} |
// gestion du double clic sur un noeud |
@Override |
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 |
@Override |
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 |
@Override |
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()); |
} |
@Override |
public boolean doBeforeNodeDrop(TreePanel treePanel, |
TreeNode target, DragData dragData, |
String point, DragDrop source, |
TreeNode dropNode, |
DropNodeCallback dropNodeCallback) { |
if(dragData instanceof TreeDragData) { |
return true; |
} |
String idMotCle = ((String[])target.getUserObject())[1]; |
if(oMediateur.gererDDObsSurMotCle(target, dragData)) { |
cocherMotCle(idMotCle); |
return true; |
} |
return false; |
} |
@Override |
public void onNodeDrop(TreePanel treePanel, |
TreeNode target, DragData dragData, |
String point, DragDrop source, TreeNode dropNode) { |
} |
}); |
// gestion de la validation |
ajouterMotCle.addListener(new ButtonListenerAdapter() { |
// lors du clic |
@Override |
public void onClick(Button button, EventObject e) { |
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
TreeNode noeudAjout; |
if(noeuds.length > 0) { |
noeudAjout = noeuds[noeuds.length - 1]; |
} else { |
noeudAjout = arbreMotsCles.getRootNode(); |
} |
ajouterNoeud(noeudAjout); |
} |
}); |
} |
/** |
* Configure le drag 'n drop pour la liste |
*/ |
private 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 |
arbreMotsCles.setDdGroup("ObsMotsClesGroup"); |
//arbreMotsCles.setEnableDD(true); |
arbreMotsCles.setEnableDrag(true); |
arbreMotsCles.setEnableDrop(true); |
DropTargetConfig dtc = new DropTargetConfig(); |
dtc.setdDdGroup("ObsMotsClesGroup"); |
} |
/** |
* 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())) { |
if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) { |
// 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"); |
// 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); |
} |
/** |
* Fonction de gestion sur le clic sur le noeud |
* |
* @param node |
*/ |
public void gererClicNoeud(TreeNode node, boolean multi) { |
if(!arbreCharge) { |
obtenirArbreMotsCles(); |
} else { |
if(multi) { |
} |
((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi); |
oMediateur.obtenirNombreObservation(); |
} |
} |
/** |
* 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 |
@Override |
public boolean execute(Node node) { |
// 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) |
.getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
return true; |
} |
} |
if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) { |
getArbreMotsCles().getNodeById(node.getId()) |
.getUI().getTextEl().removeClassName("x-tree-node-text-kw"); |
} |
// et on passe au suivant |
return true; |
} |
}); |
} |
else { |
motsClesEnAttente = motsClesIds ; |
} |
} |
public void cocherMotCle(String motCleId) { |
getArbreMotsCles().getNodeById(motCleId) |
.getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
} |
public void initialiser() { |
arbreCharge = false ; |
motsClesEnCours = ""; |
arbreMotsCles.collapseAll(); |
// on vide l'ancien arbre |
Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes(); |
for (int i = 0; i < rootChild.length; i++) { |
rootChild[i].remove(); |
} |
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
obtenirArbreMotsCles() ; |
arbreCharge = true ; |
} |
} |
}) ; |
} |
/** |
* 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 |
*/ |
@Override |
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 obs) |
if (nouvelleDonnees instanceof String) { |
String chaineMc = (String)nouvelleDonnees; |
String[] motsClesIds = chaineMc.split(";"); |
// 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 |
cocherMotsCles(motsClesIds); |
} |
// si l'arbre n'est pas encore instancié on met les mots clés en |
// attente |
else { |
motsClesEnAttente = motsClesIds; |
} |
} |
} |
private String genererIdMotCle(TreeNode nd) { |
double IdMC = (nd.hashCode() + ((Math.random() * 10000) + 1)); |
return ""+IdMC; |
} |
/** |
* 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.setUserObject(usObj); |
ndPereCopie.appendChild(child); |
if (!ndNodeFils[i].isLeaf()) { |
copierFilsNoeud(ndNodeFils[i], child); |
} |
} |
} |
} |
public void raz() { |
arbreCharge = false ; |
arbreMotsCles.collapseAll(); |
arbreMotsCles.clear() ; |
// on crée une racine pour l'arbre |
TreeNode root = new TreeNode("Projets"); |
root.setId("racine_obs"); |
String[] usObject = { "Projets", "racine_obs" }; |
root.setUserObject(usObject); |
root.setExpandable(true); |
arbreMotsCles.setRootNode(root); |
arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
obtenirArbreMotsCles() ; |
arbreCharge = true ; |
} |
} |
}) ; |
motsClesEnCours = ""; |
} |
@Override |
public boolean renvoyerEtatFiltre() { |
// TODO Auto-generated method stub |
return false; |
} |
@Override |
public String renvoyerNomFiltre() { |
// TODO Auto-generated method stub |
return null; |
} |
@Override |
public String[] renvoyerValeursAFiltrer() { |
String val = ""; |
TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
for(int i = 0; i< noeuds.length ; i++) { |
if(noeuds[i].getDepth() > 0) { |
val += ";"+noeuds[i].getId(); |
} |
} |
val = val.replaceFirst(";", ""); |
String[] valeursFiltres = {"id_mots_cles", val}; |
return valeursFiltres; |
} |
@Override |
public void valider() { |
// TODO Auto-generated method stub |
} |
public void montrerContextMenuArbre(final TreeNode n, EventObject e, |
TreeEditor te) { |
Menu mn = new Menu(); |
final com.gwtext.client.widgets.menu.Item ajoutN = new Item( |
"Ajouter un projet"); |
final com.gwtext.client.widgets.menu.Item suppN = new Item( |
"Supprimer projet"); |
mn.addItem(ajoutN); |
mn.addItem(suppN); |
mn.addListener(new MenuListenerAdapter() { |
@Override |
public void onItemClick(BaseItem item, EventObject e) { |
if (item.equals(suppN)) { |
supprimerNoeud(n); |
} |
if (item.equals(ajoutN)) { |
ajouterNoeud(n); |
} |
} |
}); |
mn.showAt(e.getXY()); |
} |
@Override |
public void viderFiltre() { |
arbreMotsCles.getSelectionModel().clearSelections(); |
motsClesEnCours = ""; |
} |
} |
Property changes: |
Added: svn:mergeinfo |
/branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java |
---|
New file |
0,0 → 1,116 |
package org.tela_botanica.client.vues.observation.filtres; |
import org.tela_botanica.client.interfaces.Filtrable; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import com.gwtext.client.core.EventCallback; |
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.form.TextField; |
public class RechercheLibreVue extends Panel implements Filtrable { |
private ObservationMediateur oMediateur = null; |
private TextField champRecherche = null; |
private static String titrePanneau = "Recherche libre"; |
private String valeurRecherchee= ""; |
private Button boutonRechercher = null; |
private boolean estModifie = true; |
private final int KEY_ENTER = 13; |
public RechercheLibreVue(ObservationMediateur om) { |
super(titrePanneau); |
oMediateur = om; |
champRecherche = new TextField(); |
champRecherche.setWidth("90%"); |
boutonRechercher = new Button("Rechercher"); |
boutonRechercher.addListener(new ButtonListenerAdapter() { |
@Override |
public void onClick(Button button, EventObject e) { |
valider(); |
} |
}); |
champRecherche.addKeyPressListener(new EventCallback() { |
@Override |
public void execute(EventObject e) { |
switch(e.getKey()) { |
case KEY_ENTER: |
valider(); |
break; |
} |
} |
}); |
add(champRecherche); |
add(boutonRechercher); |
setCollapsible(true); |
setTitleCollapse(true); |
setPaddings(5); |
} |
@Override |
public boolean renvoyerEtatFiltre() { |
return estModifie; |
} |
@Override |
public String renvoyerNomFiltre() { |
return "Recherche libre"; |
} |
@Override |
public String[] renvoyerValeursAFiltrer() { |
String nom = "recherche"; |
if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
valeurRecherchee = champRecherche.getValueAsString(); |
} else { |
valeurRecherchee = ""; |
} |
String[] valeurs = {nom,valeurRecherchee}; |
return valeurs; |
} |
@Override |
public void valider() { |
if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
estModifie = true; |
oMediateur.obtenirNombreObservation(); |
} else { |
estModifie = false; |
} |
} |
public void raz() { |
if(champRecherche.isCreated()) { |
champRecherche.reset(); |
valeurRecherchee = ""; |
} |
} |
@Override |
public void viderFiltre() { |
champRecherche.setValue(""); |
valeurRecherchee = ""; |
} |
} |
/branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java |
---|
New file |
0,0 → 1,642 |
package org.tela_botanica.client.vues.observation.filtres; |
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.objets.EntiteGeographiqueObservation; |
import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
import org.tela_botanica.client.modeles.objets.Observation; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import org.tela_botanica.client.util.Util; |
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; |
/** |
* Arbre Filtrant sur les entites geographiques |
* |
* |
* @author aurelien + david |
* |
*/ |
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; |
/** |
* 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.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 |
@Override |
public void onRender(Component component) { |
// on interdit le drag and drop dans l'arbre |
arbreEntitesGeographiques.setEnableDD(false); |
arbreEntitesGeographiques.setId("x-view-tree-filter-entity"); |
// 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() { |
@Override |
public void onClick(TreeNode node, EventObject e) { |
gererClicNoeud(node); |
} |
}) ; |
arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirListeEntiteGeographique() ; |
arbreCharge = true ; |
} |
} |
}) ; |
} |
private void gererClicNoeud(TreeNode node) { |
mettreAJourValeurEnCours(node); |
observationMediateur.obtenirNombreObservation() ; |
} |
private void mettreAJourValeurEnCours(TreeNode node) { |
nomFiltre = "" ; |
entitesGeographiquesEncours = "" ; |
String nomPere = "" ; |
String nomGrandPere = "" ; |
String nomArriereGrandPere = ""; |
switch(node.getDepth()) |
{ |
case 0: |
if(!arbreCharge) |
{ |
arbreEntitesGeographiques.getRootNode().expand(); |
} |
else |
{ |
observationMediateur.obtenirNombreObservation() ; |
} |
return ; |
case 4: nomFiltre += "station,lieudit,commune,departement"; |
nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ; |
entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ; |
break; |
case 3: nomFiltre += "lieudit,commune,departement"; |
nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ; |
break; |
case 2: nomFiltre += "commune,departement"; |
nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
entitesGeographiquesEncours += node.getText()+","+nomPere ; |
break; |
case 1: nomFiltre += "departement"; |
entitesGeographiquesEncours += node.getText() ; |
break; |
default: |
break; |
} |
filtreModifie = true ; |
} |
public void initialiser() { |
arbreCharge = false ; |
entitesGeographiquesEncours = ""; |
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() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirListeEntiteGeographique() ; |
arbreCharge = true ; |
} |
} |
}) ; |
} |
/** |
* Méthode héritée de l'interface rafraichissable |
*/ |
@Override |
public void rafraichir(Object nouvelleDonnees, |
boolean repandreRaffraichissement) { |
if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) { |
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 vide tous les noeuds |
arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() { |
@Override |
public boolean execute(Node node) { |
node.remove(); |
return true; |
} |
}); |
// on la parse et on récupère les informations qui nous interessent |
for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
EntiteGeographiqueObservation ent=data.get(it.next()); |
creerHierarchieNoeud(nouvelArbre ,root, ent); |
doLayout(); |
} |
copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode()); |
arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ; |
// 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) |
{ |
// Cas d'ajout unitaire d'une 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 ; |
EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation()); |
creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent); |
doLayout(); |
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 |
*/ |
@Override |
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 |
*/ |
@Override |
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) |
*/ |
@Override |
public boolean renvoyerEtatFiltre() { |
return filtreModifie; |
} |
@Override |
public void valider() { |
if (estInstancie) { |
} |
} |
public Comparator<TreeNode> comparerNoeuds() |
{ |
return new Comparator<TreeNode>() { |
@Override |
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.getId() ; |
String n2 = o2.getId() ; |
return n1.compareToIgnoreCase(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() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirDatesObservation() ; |
arbreCharge = true ; |
} |
} |
}) ; |
entitesGeographiquesEncours = ""; |
} |
private TreeNode creerNoeud(String id, String texte) { |
TreeNode nouveauNoeud = new TreeNode(); |
nouveauNoeud.setId(""+(id)); |
nouveauNoeud.setText(texte); |
String[] usObj = {texte,id+""}; |
nouveauNoeud.setUserObject(usObj); |
return nouveauNoeud; |
} |
/** |
* |
* @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds |
* @param root le noeud racine auquel on concatène la hierarchie crée |
* @param ent l'entité géographique qui doit être décomposée en arborescence |
* @return |
*/ |
private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) { |
String id_zone_geo=null; |
String zone_geo=null; |
String lieuDit=null; |
String station=null; |
// TODO creer une fonction plus efficace lors du passage au multi reférentiel |
id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo()); |
id_zone_geo = id_zone_geo.replaceAll("\"", ""); |
id_zone_geo = id_zone_geo.replace('\\',' '); |
id_zone_geo = id_zone_geo.trim(); |
zone_geo = ent.getZoneGeo(); |
lieuDit = ent.getLieuDit(); |
station = ent.getStation(); |
if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) { |
id_zone_geo="Inconnue" ; |
} |
if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) { |
zone_geo="Inconnue" ; |
} |
if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
lieuDit="Inconnue" ; |
} |
if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) { |
station="Inconnue" ; |
} |
Node noeudMemeId = arbre.getNodeById(""+id_zone_geo); |
if(noeudMemeId == null) { |
// on crée le noeud de l'identifiant zone_geo |
noeudMemeId = creerNoeud(""+id_zone_geo,id_zone_geo); |
root.appendChild(noeudMemeId) ; |
} |
// on teste si la localité existe |
Node noeudMemeLoc = arbre.getNodeById(""+(id_zone_geo+zone_geo)); |
if(noeudMemeLoc == null) |
{ |
// on crée le noeud de la zone_geo |
noeudMemeLoc = creerNoeud(""+id_zone_geo+zone_geo, zone_geo); |
noeudMemeId.appendChild(noeudMemeLoc) ; |
} |
// on teste si le lieu dit existe |
Node noeudMemeLieu = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit)); |
if(noeudMemeLieu == null) |
{ |
// on crée le noeud du lieu dit |
noeudMemeLieu = creerNoeud(id_zone_geo+zone_geo+lieuDit, lieuDit); |
noeudMemeLoc.appendChild(noeudMemeLieu) ; |
} |
// on teste si la station existe |
Node noeudMemeStation = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit+station)); |
if(noeudMemeStation == null) { |
// on crée le noeud de la station |
noeudMemeStation = creerNoeud(id_zone_geo+zone_geo+lieuDit+station,station); |
noeudMemeLieu.appendChild(noeudMemeStation); |
} |
root.sort(comparerNoeuds()) ; |
} |
@Override |
public void viderFiltre() { |
arbreEntitesGeographiques.getSelectionModel().clearSelections(); |
entitesGeographiquesEncours =""; |
} |
public void viderFiltre(String nom) { |
final int profondeur = calculerProfondeurPourNomFiltre(nom); |
// on vide tous les noeuds |
arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() { |
@Override |
public boolean execute(Node node) { |
boolean continuer = true; |
TreeNode noeudArbreEncours = (TreeNode)node; |
if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) { |
int profondeurDepart = noeudArbreEncours.getDepth(); |
for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
} |
arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours); |
mettreAJourValeurEnCours(noeudArbreEncours); |
continuer = false; |
} |
return continuer; |
} |
}); |
} |
private int calculerProfondeurPourNomFiltre(String nom) { |
int profondeur = 0; |
if(nom.equals("departement")) { |
profondeur = 1; |
} |
if(nom.equals("commune")) { |
profondeur = 2; |
} |
if(nom.equals("lieudit")) { |
profondeur = 3; |
} |
if(nom.equals("station")) { |
profondeur = 4; |
} |
return profondeur; |
} |
} |
Property changes: |
Added: svn:mergeinfo |
/branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
---|
New file |
0,0 → 1,683 |
package org.tela_botanica.client.vues.observation.filtres; |
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.objets.DateObservation; |
import org.tela_botanica.client.modeles.objets.ListeDate; |
import org.tela_botanica.client.modeles.objets.Observation; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import org.tela_botanica.client.util.Util; |
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.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 |
@Override |
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.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() { |
@Override |
public void onClick(TreeNode node, EventObject e) { |
gererClicNoeud(node); |
} |
}) ; |
arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirDatesObservation() ; |
arbreCharge = true ; |
} |
} |
}) ; |
} |
private void gererClicNoeud(TreeNode node) { |
mettreAJourValeurEnCours(node); |
observationMediateur.obtenirNombreObservation() ; |
} |
private void mettreAJourValeurEnCours(TreeNode node) { |
nomFiltre = "" ; |
donneesDateEnCours = "" ; |
String nomPere = "" ; |
String nomGrandPere = "" ; |
switch(node.getDepth()) |
{ |
case 0: |
if(arbreCharge) { |
nomFiltre = ""; |
donneesDateEnCours = ""; |
} |
break; |
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 ; |
} |
public void initialiser() { |
arbreCharge = false ; |
donneesDateEnCours = ""; |
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() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirDatesObservation() ; |
arbreCharge = true ; |
} |
} |
}) ; |
} |
/** |
* Méthode héritée de l'interface rafraichissable |
*/ |
@Override |
public void rafraichir(Object nouvelleDonnees, |
boolean repandreRaffraichissement) { |
if (nouvelleDonnees instanceof ListeDate) { |
String annee=null; |
String mois=null; |
String jour=null; |
ListeDate data = (ListeDate) 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=data.get(it.next()); |
annee= ent.getAnnee() ; |
mois= ent.getMois() ; |
String moisLettre = Util.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() { |
@Override |
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 = Util.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 |
*/ |
@Override |
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 |
*/ |
@Override |
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) |
*/ |
@Override |
public boolean renvoyerEtatFiltre() { |
return filtreModifie; |
} |
@Override |
public void valider() { |
if (estInstancie) { |
} |
} |
public Comparator<TreeNode> comparerNoeuds() |
{ |
return new Comparator<TreeNode>() { |
@Override |
public int compare(TreeNode o1, TreeNode o2) { |
String n1 = ((String[])o1.getUserObject())[1] ; |
String n2 = ((String[])o2.getUserObject())[1] ; |
return n1.compareTo(n2) ; |
} |
} ; |
} |
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() { |
@Override |
public void onExpand(Node node) { |
if(!arbreCharge) |
{ |
observationMediateur.obtenirDatesObservation() ; |
arbreCharge = true ; |
} |
} |
}) ; |
this.doLayout() ; |
donneesDateEnCours = ""; |
} |
@Override |
public void viderFiltre() { |
arbreDonneesDates.getSelectionModel().clearSelections(); |
donneesDateEnCours = ""; |
} |
public void viderFiltre(String nom) { |
final int profondeur = calculerProfondeurPourNomFiltre(nom); |
// on vide tous les noeuds |
arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
@Override |
public boolean execute(Node node) { |
boolean continuer = true; |
TreeNode noeudArbreEncours = (TreeNode)node; |
if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
int profondeurDepart = noeudArbreEncours.getDepth(); |
for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
} |
arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
mettreAJourValeurEnCours(noeudArbreEncours); |
continuer = false; |
} |
return continuer; |
} |
}); |
} |
private int calculerProfondeurPourNomFiltre(String nom) { |
int profondeur = 0; |
if(nom.equals("annee")) { |
profondeur = 1; |
} |
if(nom.equals("mois")) { |
profondeur = 2; |
} |
if(nom.equals("jour")) { |
profondeur = 3; |
} |
return profondeur; |
} |
} |
Property changes: |
Added: svn:mergeinfo |