Rev 39 | Blame | Last modification | View Log | RSS feed
package org.tela_botanica.client.observation;
import java.util.Iterator;
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
import org.tela_botanica.client.vues.ListeObservationVue;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
/**
* Mediateur gérant les interactions entre vues et les echanges de données
* C'est un singleton.
* @author aurelien
*
*/
public class ObservationMediateur implements Rafraichissable {
/**
* booleen qui verifie l'unicite de l'instance (donc static)
*/
private static boolean estInstancie = false ;
/**
* pointeur sur le médiateur (pour le pattern singleton)
*/
private static ObservationMediateur thisMediateur = null ;
/** Mediateur general de l'application carnet en ligne
*
*
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* modele de données
*/
private ObservationModele observationModele = null ;
/**
* panneau principal des Observation (onglet "observation")
*/
private final Panel panneauPrincipalObservation = new Panel("Observation");
/**
* panneau a onglet pour la liste
*/
private TabPanel ongletsObservation = null ;
/**
* conteneur du panneau a onglets
*/
private Panel panneauMenuEtOngletsObservation = null ;
/**
* liste détaillée des Observations
*/
private ListeObservationVue listeObservation = null ;
/**
* Saisie des Observations
*/
private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
/**
* l'indice du dernier onglet sélectionné
*/
private int dernierIndexOnglet = 0 ;
/**
* booleen explicitant s'il y a une selection en cours
*/
private boolean selection = false ;
/**
* Numéro de page en cours
*/
private int pageEncours = 0 ;
/**
* Nombre de pages totales
*/
private int pageMax = 1 ;
/**
* Taille de page (par défaut 20)
*/
private int taillePage = 20 ;
/**
* Nombre d'éléments total correspondant à la requete
*/
private int nbElements = 0 ;
/**
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
*/
private Store st = null ;
/**
* La liste des observations affichées en cours (verifier utilité)
*/
private ListeObservation cacheObservation = new ListeObservation(0) ;
/**
/**
* constructeur privé (on accède a la classe par la méthode getInstance
*/
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
{
this.carnetEnLigneMediateur=carnetEnLigneMediateur;
// on crée un modèle
observationModele = ObservationModele.Instance(this);
// on gère la mise en page du panneau principal
//panneauPrincipalObservation.setLayout(new BorderLayout());
// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
// panneauMenuEtOngletsObservation = new Panel("gg") ;
// panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
// le panneau à onglet qui contient la vue
//ongletsObservation = new TabPanel();
// la liste des observations
//Panel panneauListeObservation = new Panel("Liste");
listeObservation = new ListeObservationVue(this);
// Le formulaire de saisie / modification d'observation
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
//panneauListeObservation.setLayout(new FitLayout());
//panneauListeObservation.setSize(600,600);
//panneauListeObservation.add(listeObservation);
// on ajoute les panneaux au panneau à onglets
//ongletsObservation.add(panneauListeObservation);
// les onglets au centre
// panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
// on ajoute le panneau qui contient le menu et les onglets d'images au centre
//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
panneauPrincipalObservation.add(formulaireSaisieObservationVue);
panneauPrincipalObservation.add(listeObservation);
}
/**
* Retourne une instance de manière unique
* @return l'instance unique du médiateur
*/
public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
{
if(!estInstancie || thisMediateur == null)
{
estInstancie = true ;
thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
}
return thisMediateur ;
}
/**
* envoie au modèle une demande de mise a jour
*/
public void obtenirNombreObservation() {
listeObservation.masquerChargement();
observationModele.obtenirNombreObservation(this) ;
}
/**
* envoie au modèle une demande de mise a jour
*/
public void obtenirListeObservation() {
observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
}
/**
* C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
* sous forme de tableau [nom, valeur]
* @return Les noms et valeurs des filtres
*/
public String[][] renvoyerFiltres()
{
String[][] valeursFiltres = { {"",""} } ;
return valeursFiltres ;
}
public String getIdentifiant() {
return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
}
public Panel getPanneauPrincipalObservation() {
return panneauPrincipalObservation;
}
// FIXME TODO : plutot dans la listevu non ?
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
// si l'on a reçu une liste d'observation
if(nouvelleDonnees instanceof ListeObservation)
{
ListeObservation data = (ListeObservation) nouvelleDonnees ;
Object[][] observationData = new Object[data.size()][8];
int i = 0 ;
if(data.size() == 0)
{
pageEncours = 0 ;
}
// on la parse et on récupère les informations quiç nous interessent
for (Iterator it = data.keySet().iterator(); it.hasNext();)
{
Observation obs=(Observation) data.get(it.next());
observationData[i][0]= obs.getTransmis();
observationData[i][1]= obs.getNomSaisi();
observationData[i][2]= obs.getNomRetenu();
observationData[i][3]= obs.getLieudit();
observationData[i][4]= obs.getDate();
observationData[i][5]= obs.getNumeroOrdre();
i++ ;
}
// creation du store qui les contient
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
// on associe le store
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation };
RecordDef rd = new RecordDef(defTab);
final MemoryProxy dataProxy = new MemoryProxy(observationData);
final ArrayReader reader = new ArrayReader(rd);
final Store observationStore = new Store(dataProxy, reader);
st = observationStore ;
st.load() ;
// par défaut le store est trié sur l'ordre d'observations
st.sort("ordre_observation") ;
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
if(repandreRafraichissement)
{
listeObservation.rafraichir(st, false) ;
}
}
// Si on reçoit un tableau d'entiers
// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
if(nouvelleDonnees instanceof int[])
{
int[] pages = (int[])nouvelleDonnees ;
// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
pageMax = calculerNbPages(pages[0]) ;
nbElements = pages[0] ;
// et on notifie de le mediateur du changement des valeurs
changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
obtenirListeObservation();
}
}
/**
* Met à jour les barre d'outils avec des nouvelles valeurs
* @param pageMax le nombre de pages
* @param pageEncours la page en cours
* @param taillePage la taille de page
* @param nbElement le nombre d'élements par page
*/
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
{
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
listeObservation.getToolBarVue().rafraichir(pages, false) ;
}
/**
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
* en cours
* @param nbElements le nombre d'élements total
* @return le nombre de pages
*/
public int calculerNbPages(int nbElements)
{
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
// pour eviter qu'il arrondisse mal la division
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
double nPage = (1.0*nbElements)/(1.0*taillePage) ;
double nPageRound = Math.ceil(nPage) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return nPageInt.intValue() ;
}
/**
* Recalcule la page en cours lors du changement du nombre d'élements
* @param nbElements le nombre d'élements total
* @return la nouvelle page encours
*/
public int calculerPageCourante(int nbElements)
{
// on calcule le nombre de page
int nouvelNbPages = calculerNbPages(nbElements) ;
// la nouvelle page en cours
double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
// on arrondit au supérieur
double nPageRound = Math.ceil(nPageCourante) ;
Double nPageInt = new Double(nPageRound) ;
// on convertit en entier
return Math.abs(nPageInt.intValue()) ;
}
/**
* Appelle le modèle pour lui demander les données d'une page à afficher
* @param pageCourante le numéro de page à affciher
*/
public void changerNumeroPage(int pageCourante) {
pageEncours = pageCourante ;
// On lance le chargerment des observations
obtenirNombreObservation();
listeObservation.getToolBarVue().changerPageCourante(pageCourante);
}
/**
* Appelle le modèle pour qu'il change la taille de page utilisée
* @param nouvelleTaillePage la nouvelle taille de page
*/
public void changerTaillePage(int nouvelleTaillePage)
{
taillePage = nouvelleTaillePage ;
pageEncours = calculerPageCourante(nbElements) ;
// On lance le chargerment des observations
obtenirNombreObservation();
// et on met à jour la taille de page dans les barres d'outils
listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
}
/**
*
* Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
observationModele.obtenirListeReferentielCommune(r,critere) ;
}
/**
*
* Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
observationModele.obtenirListeReferentielNom(r,critere) ;
}
/**
*
* Lance la creation d'une observation
* @param r : la vue demandeuse de donnee
* @param critere : les criteres de selection
*/
public void ajouterObservation(Rafraichissable r, Observation obs) {
observationModele.ajouterObservation(r, obs) ;
}
public void clicListeObservation(int rowIndex) {
}
public void montrerContextMenu(EventObject e) {
}
public void doubleClicListeObservation(int rowIndex) {
}
}