Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.vues.collection;

import java.util.HashMap;

import java.util.Iterator;

import org.tela_botanica.client.Coel;

import org.tela_botanica.client.ComposantClass;

import org.tela_botanica.client.ComposantId;

import org.tela_botanica.client.Mediateur;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.Information;

import org.tela_botanica.client.modeles.OntologiesLocales;

import org.tela_botanica.client.modeles.ValeurListe;

import org.tela_botanica.client.modeles.collection.Collection;

import org.tela_botanica.client.modeles.collection.CollectionACommentaire;

import org.tela_botanica.client.modeles.collection.CollectionACommentaireListe;

import org.tela_botanica.client.modeles.collection.CollectionAPersonne;

import org.tela_botanica.client.modeles.collection.CollectionAPersonneListe;

import org.tela_botanica.client.modeles.collection.CollectionAPublication;

import org.tela_botanica.client.modeles.collection.CollectionAPublicationListe;

import org.tela_botanica.client.modeles.collection.CollectionBotanique;

import org.tela_botanica.client.modeles.commentaire.Commentaire;

import org.tela_botanica.client.modeles.personne.Personne;

import org.tela_botanica.client.modeles.publication.Publication;

import org.tela_botanica.client.modeles.structure.Structure;

import org.tela_botanica.client.synchronisation.Sequenceur;

import org.tela_botanica.client.util.Debug;

import org.tela_botanica.client.util.UtilString;

import org.tela_botanica.client.vues.DetailVue;

import com.extjs.gxt.ui.client.Style.Scroll;

import com.extjs.gxt.ui.client.util.Format;

import com.extjs.gxt.ui.client.util.Params;

import com.extjs.gxt.ui.client.widget.ContentPanel;

import com.extjs.gxt.ui.client.widget.Html;

import com.extjs.gxt.ui.client.widget.TabItem;

import com.extjs.gxt.ui.client.widget.TabPanel;

import com.extjs.gxt.ui.client.widget.layout.AnchorLayout;

import com.extjs.gxt.ui.client.widget.layout.FitLayout;

public class CollectionDetailVue extends DetailVue implements Rafraichissable {

	private Collection collection = null;

	private boolean collectionChargementOk = false;

	private boolean personnesLieesChargementOk = false;

	private boolean publicationsLieesChargementOk = false;

	private boolean commentairesLieesChargementOk = false;

	private Structure structure = null;

	private String enteteTpl = null;

	private String generalTpl = null;

	private String personneTpl = null;

	private String tableauPersonnesLieesTpl = null;

	private String lignePersonneLieeTpl = null;

	private String publicationTpl = null;

	private String tableauPublicationsLieesTpl = null;

	private String lignePublicationLieeTpl = null;

	private String descriptionTpl = null;

	private String contenuTpl = null;

	private String inventaireTpl = null;

	private String commentaireTpl = null;

	private String tableauCommentairesLieesTpl = null;

	private String ligneCommentaireLieeTpl = null;

	private ContentPanel panneauPrincipal = null;

	private Html entete = null;

	private TabPanel onglets = null;

	private TabItem generalOnglet = null;

	private TabItem personneOnglet = null;

	private TabItem publicationOnglet = null;

	private TabItem descriptionOnglet = null;

	private TabItem contenuOnglet = null;

	private TabItem inventaireOnglet = null;

	private TabItem commentaireOnglet = null;

	private Sequenceur sequenceur;

	public CollectionDetailVue(Mediateur mediateurCourant, Sequenceur sequenceur) {

		super(mediateurCourant);

		this.sequenceur = sequenceur;

		initialiserTousLesTpl();

		chargerOntologie();

		panneauPrincipal = new ContentPanel();

		panneauPrincipal.setLayout(new FitLayout());

		panneauPrincipal.setHeaderVisible(false);

		panneauPrincipal.setBodyBorder(false);

	    entete = new Html();

	    entete.setId(ComposantId.ZONE_DETAIL_ENTETE);

	    panneauPrincipal.setTopComponent(entete);

		onglets = new TabPanel();

		onglets.setId(ComposantId.ZONE_DETAIL_CORPS);

		onglets.setBodyBorder(false);

		generalOnglet = new TabItem(i18nC.structureInfoGeneral());

		generalOnglet.setLayout(new AnchorLayout());

		generalOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(generalOnglet);

		personneOnglet = new TabItem(i18nC.collectionPersonne());

		personneOnglet.setLayout(new AnchorLayout());

		personneOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(personneOnglet);

		publicationOnglet = new TabItem(i18nC.collectionPublication());

		publicationOnglet.setLayout(new AnchorLayout());

		publicationOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(publicationOnglet);

		descriptionOnglet = new TabItem(i18nC.collectionDescription());

		descriptionOnglet.setLayout(new AnchorLayout());

		descriptionOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(descriptionOnglet);

		contenuOnglet = new TabItem(i18nC.collectionContenu());

		contenuOnglet.setLayout(new AnchorLayout());

		contenuOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(contenuOnglet);

		inventaireOnglet = new TabItem(i18nC.collectionInventaire());

		inventaireOnglet.setLayout(new AnchorLayout());

		inventaireOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(inventaireOnglet);

		commentaireOnglet = new TabItem(i18nC.collectionCommentaire());

		commentaireOnglet.setLayout(new AnchorLayout());

		commentaireOnglet.setScrollMode(Scroll.AUTO);

		onglets.add(commentaireOnglet);

		panneauPrincipal.add(onglets);

		add(panneauPrincipal);

	}

	private void initialiserTousLesTpl() {

		initialiserEnteteHtmlTpl();

		initialiserGeneralTpl();

		initialiserPersonneTpl();

		initialiserTableauPersonnesLieesTpl();

		initialiserLignePersonneLieeTpl();

		initialiserPublicationTpl();

		initialiserTableauPublicationsLieesTpl();

		initialiserLignePublicationLieeTpl();

		initialiserContenuTpl();

		initialiserDescriptionTpl();

		initialiserInventaireTpl();

		initialiserCommentaireTpl();

		initialiserTableauCommentairesLieesTpl();

		initialiserLigneCommentaireLieeTpl();

	}

	private void initialiserEnteteHtmlTpl() {

		enteteTpl =

			"<div id='{css_id}'>"+

			"	<h1>{nom}</h1>"+

			"	<h2>{structure}<span class='{css_meta}'><br /> {i18n_id}:{id} - {guid}</span></h2>" +

			"</div>";

	}

	private void initialiserGeneralTpl() {

		generalTpl =

			"<div class='{css_corps}'>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_identification}</h2>"+

			"		<span class='{css_label}'>{i18n_nom_alternatif} :</span> {nom_alternatif}<br />"+

			"		<span class='{css_label}'>{i18n_mere} :</span> {mere}<br />"+

			"		<span class='{css_label}'>{i18n_type_ncd} :</span> {type_ncd}<br />"+

			"		<span class='{css_label}'>{i18n_type_depot} :</span> {type_depot}<br />"+

			"		<span class='{css_label}'>{i18n_code} :</span> {code}<br />"+

			"		<span class='{css_label}'>{i18n_cote} :</span> {cote}<br />"+

			"	</div>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_general_collection_titre}</h2>"+

			"		<span class='{css_label}'>{i18n_description} :</span> {description}<br />"+

			"		<span class='{css_label}'>{i18n_historique} :</span> {historique}<br />"+

			"		<span class='{css_label}'>{i18n_web} :</span> {web}<br />"+

			"	</div>"+

			"	<hr class='{css_clear}'/>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_couverture_collection_titre}</h2>"+

			"		<span class='{css_label}'>{i18n_couverture_geo} :</span> {couverture_geo}<br />"+

			"		<span class='{css_label}'>{i18n_periode} :</span> {periode}<br />"+

			"	</div>"+

			"	</div>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_specimen_type_titre}</h2>"+

			"		<span class='{css_label}'>{i18n_specimen_type_presence} :</span> {specimen_type_presence}<br />"+

			"		<span class='{css_label}'>{i18n_specimen_type_nombre} :</span> {specimen_type_nombre}<br />"+

			"		<span class='{css_label}'>{i18n_specimen_type_classement} :</span> {specimen_type_classement}<br />"+

			"	</div>"+

			"	<hr class='{css_clear}'/>"+

			"</div>";

	}

	private void initialiserPersonneTpl() {

		personneTpl =

			"<div class='{css_corps}'>"+

			"	<h2>{i18n_titre_personne}</h2>"+

			"	{tableau_personnes_liees}"+

			"</div>";

	}

	private void initialiserTableauPersonnesLieesTpl() {

		tableauPersonnesLieesTpl =

			"<table>"+

			"	<thead>"+

			"		<tr>" +

			"			<th>{i18n_relation}</th>" +

			"			<th>{i18n_nom_complet}</th>" +

			"			<th>{i18n_nom}</th>" +

			"			<th>{i18n_prenom}</th>" +

			"			<th>{i18n_naissance_date}</th>" +

			"			<th>{i18n_naissance_lieu}</th>" +

			"			<th>{i18n_etre_decede}</th>" +

			"			<th>{i18n_deces_date}</th>" +

			"			<th>{i18n_deces_lieu}</th>" +

			"		</tr>"+

			"	</thead>"+

			"	<tbody>"+

			"		{lignes}"+

			"	</tbody>"+

			"</table>";

	}

	private void initialiserLignePersonneLieeTpl() {

		lignePersonneLieeTpl =

			"<tr>"+

			"	<td>{relation}</td>"+

			"	<td>{nom_complet}</td>"+

			"	<td>{nom}</td>"+

			"	<td>{prenom}</td>"+

			"	<td>{naissance_date}</td>"+

			"	<td>{naissance_lieu}</td>"+

			"	<td>{etre_decede}</td>"+

			"	<td>{deces_date}</td>"+

			"	<td>{deces_lieu}</td>"+

			"</tr>";

	}

	private void initialiserPublicationTpl() {

		publicationTpl =

			"<div class='{css_corps}'>"+

			"	<h2>{i18n_titre_publication}</h2>"+

			"	{tableau_publications_liees}"+

			"</div>";

	}

	private void initialiserTableauPublicationsLieesTpl() {

		tableauPublicationsLieesTpl =

			"<table>"+

			"	<thead>"+

			"		<tr>" +

			"			<th>{i18n_auteur}</th>" +

			"			<th>{i18n_titre}</th>" +

			"			<th>{i18n_revue}</th>" +

			"			<th>{i18n_editeur}</th>" +

			"			<th>{i18n_annee}</th>" +

			"			<th>{i18n_nvt}</th>" +

			"			<th>{i18n_fascicule}</th>" +

			"			<th>{i18n_page}</th>" +

			"			<th>{i18n_source}</th>" +

			"		</tr>"+

			"	</thead>"+

			"	<tbody>"+

			"		{lignes}"+

			"	</tbody>"+

			"</table>";

	}

	private void initialiserLignePublicationLieeTpl() {

		lignePublicationLieeTpl =

			"<tr>"+

			"	<td>{auteur}</td>"+

			"	<td>{titre}</td>"+

			"	<td>{revue}</td>"+

			"	<td>{editeur}</td>"+

			"	<td>{annee}</td>"+

			"	<td>{nvt}</td>"+

			"	<td>{fascicule}</td>"+

			"	<td>{page}</td>"+

			"	<td>{source}</td>"+

			"</tr>";

	}

	private void initialiserDescriptionTpl() {

		descriptionTpl =

			"<div class='{css_corps}'>"+

			"	<div>"+

			"		<h2>{i18n_titre_description}</h2>"+

			"		<span class='{css_label}'>{i18n_type_botanique} :</span> {type_botanique}<br />"+

			"		<span class='{css_label}'>{i18n_nbre_echantillon} :</span> {nbre_echantillon}<br />"+

			"		<span class='{css_label}'>{i18n_etat_unite_rangement} :</span> {etat_unite_rangement}<br />"+

			"		<span class='{css_label}'>{i18n_collection_cartons_herbiers} :</span> {nb_cartons_herbier}<br />"+

			"		<span class='{css_label}'>{i18n_nb_liasses} :</span> {nb_liasses}<br />"+

			"		<span class='{css_label}'>{i18n_autres_unites_rangement} : </span>{autres_unites_rangement}<br />"+

			"		<span class='{css_label}'>{i18n_nb_planches_herbier} :</span> {nb_planches_herbier}<br />"+

			"		<span class='{css_label}'>{i18n_nb_especes} :</span> {nb_especes}<br />"+

			"	</div>"+

			"	<div>"+

			"		<h2>{i18n_titre_conservation}</h2>"+

			"		<span class='{css_label}'>{i18n_type_papier} :</span> {type_papier}<br />"+

			"		<span class='{css_label}'>{i18n_conservation_methode} :</span> {conservation_methode}<br />"+

			"	</div>"+

			"	<div>"+

			"		<h2>{i18n_titre_etiquette}</h2>"+

			"		<span class='{css_label}'>{i18n_specimen_fixation_pourcent} :</span> {specimen_fixation_pourcent}<br />"+

			"		<span class='{css_label}'>{i18n_etiquette_fixation_pourcent} :</span> {etiquette_fixation_pourcent}<br />"+

			"		<span class='{css_label}'>{i18n_specimen_fixation_methode} :</span> {specimen_fixation_methode}<br />"+

			"		<span class='{css_label}'>{i18n_etiquette_fixation_methode_support} :</span> {etiquette_fixation_methode_support}<br />"+

			"		<span class='{css_label}'>{i18n_etiquette_fixation_methode_specimen} :</span> {etiquette_fixation_methode_specimen}<br />"+

			"		<span class='{css_label}'>{i18n_etiquette_type_ecriture} :</span> {etiquette_type_ecriture}<br />"+

			"	</div>"+

			"	<div>"+

			"		<h2>{i18n_titre_traitement}</h2>"+

			"		<span class='{css_label}'>{i18n_traitement} :</span> {traitement}<br />"+

			"		<span class='{css_label}'>{i18n_traitement_poison} :</span> {traitement_poison}<br />"+

			"		<span class='{css_label}'>{i18n_traitement_insecte} :</span> {traitement_insecte}<br />"+

			"	</div>"+

			"	<div>"+

			"		<h2>{i18n_titre_etat_degradation}</h2>"+

			"		<span class='{css_label}'>{i18n_etat_general} :</span> {etat_general}<br />"+

			"		<span class='{css_label}'>{i18n_degradation_specimen} :</span> {degradation_specimen}<br />"+

			"		<span class='{css_label}'>{i18n_degradation_presentation} :</span> {degradation_presentation}<br />"+

			"		<span class='{css_label}'>{i18n_determination} :</span> {determination}<br />"+

			"	</div>"+

			"</div>";

	}

	private void initialiserContenuTpl() {

		contenuTpl =

			"<div class='{css_corps}'>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_nature}</h2>"+

			"		<span class='{css_label}'>{i18n_nature} :</span> {nature}<br />"+

			"		<span class='{css_label}'>{i18n_specialite} :</span> {specialite}<br />"+

			"	</div>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_etiquette}</h2>"+

			"		<span class='{css_label}'>{i18n_etiquette_renseignement} :</span> {etiquette_renseignement}<br />"+

			"		<span class='{css_label}'>{i18n_precision_localite} :</span> {precision_localite}<br />"+

			"		<span class='{css_label}'>{i18n_precision_date} :</span> {precision_date}<br />"+

			"		<span class='{css_label}'>{i18n_etiquette_annotation} :</span> {etiquette_annotation}<br />"+

			"	</div>"+

			"	<hr class='{css_clear}'/>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_classement}</h2>"+

			"		<span class='{css_label}'>{i18n_classement_etat} :</span> {classement_etat}<br />"+

			"		<span class='{css_label}'>{i18n_classement} :</span> {classement}<br />"+

			"	</div>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_integree}</h2>"+

			"		<span class='{css_label}'>{i18n_collection_integration} :</span> {collection_integration}<br />"+

			"		<span class='{css_label}'>{i18n_collection_integration_info} :</span> {collection_integration_info}<br />"+

			"	</div>"+

			"</div>";

	}

	private void initialiserInventaireTpl() {

		inventaireTpl =

			"<div class='{css_corps}'>"+

			"	<div class='{css_fieldset}'>"+

			"		<h2>{i18n_titre_inventaire}</h2>"+

			"		<span class='{css_label}'>{i18n_existence} :</span> {existence}<br />"+

			"		<span class='{css_label}'>{i18n_participation_auteur} :</span> {participation_auteur}<br />"+

			"		<span class='{css_label}'>{i18n_forme} :</span> {forme}<br />"+

			"		<span class='{css_label}'>{i18n_info} :</span> {info}<br />"+

			"		<span class='{css_label}'>{i18n_digital} :</span> {digital}<br />"+

			"		<span class='{css_label}'>{i18n_digital_pourcent} :</span> {digital_pourcent}<br />"+

			"		<span class='{css_label}'>{i18n_etat} :</span> {etat}<br />"+

			"	</div>"+

			"	<hr class='{css_clear}'/>"+

			"</div>";

	}

	private void initialiserCommentaireTpl() {

		commentaireTpl =

			"<div class='{css_corps}'>"+

			"	<h2>{i18n_titre_commentaire}</h2>"+

			"	{tableau_commentaires_liees}"+

			"</div>";

	}

	private void initialiserTableauCommentairesLieesTpl() {

		tableauCommentairesLieesTpl =

			"<table>"+

			"	<thead>"+

			"		<tr>" +

			"			<th>{i18n_type}</th>" +

			"			<th>{i18n_titre}</th>" +

			"			<th>{i18n_ponderation}</th>" +

			"			<th>{i18n_public}</th>" +

			"		</tr>"+

			"	</thead>"+

			"	<tbody>"+

			"		{lignes}"+

			"	</tbody>"+

			"</table>";

	}

	private void initialiserLigneCommentaireLieeTpl() {

		ligneCommentaireLieeTpl =

			"<tr>"+

			"	<td>{type}</td>"+

			"	<td>{titre}</td>"+

			"	<td>{ponderation}</td>"+

			"	<td>{public}</td>"+

			"</tr>"+

			"<tr>"+

			"	<td colspan='4'>{texte}</td>"+

			"</tr>";

	}

	private void chargerOntologie() {

		String[] listesCodes = {"typeCollectionBota", "typeCollectionNcd", "typeDepot", "groupementPrincipe",

			"realisationBut", "onpi", "ea", "typeClassement", "relationPersonneCollection", "ion",

			"typeUniteRangement", "etat", "typeUniteBase", "typePapier", "methodeRangement", "methodeFixation",

			"methodeFixationSurSpecimen", "typeEcriture", "poisonTraitement", "insecteTraitement", "specimenDegradation",

			"niveauImportance", "supportDegradation", "niveauDetermination", "natureVegetale", "siecleNaturaliste",

			"dateDebut", "dateFin", "etat", "onep", "onp", "inventaireForme", "inventaireLogiciel", "inventaireEtat",

			"etatClassement", "typeCommentaireCollection"};

		lancerChargementListesValeurs(listesCodes, sequenceur);

		sequenceur.enfilerRafraichissement(this, new Information("ontologie_chargee"));

	}

	public void rafraichir(Object nouvellesDonnees) {

		if (nouvellesDonnees instanceof Collection) {

			collection = (Collection) nouvellesDonnees;

			collectionChargementOk = true;

		} else if (nouvellesDonnees instanceof ValeurListe) {

			ValeurListe listeValeursReceptionnee = (ValeurListe) nouvellesDonnees;

			receptionerListeValeurs(listeValeursReceptionnee);

		} else if (nouvellesDonnees instanceof Information) {

			Information info = (Information) nouvellesDonnees;

			if (info.getType().equals("liste_collection_a_personne")) {

				lierCollectionAPersonne((CollectionAPersonneListe) info.getDonnee(0));

			} else if (info.getType().equals("liste_collection_a_publication")) {

				lierCollectionAPublication((CollectionAPublicationListe) info.getDonnee(0));

			} else if (info.getType().equals("liste_collection_a_commentaire")) {

				lierCollectionACommentaire((CollectionACommentaireListe) info.getDonnee(0));

			} else if (info.getType().equals("ontologie_chargee")) {

				ontologieChargementOk = true;

			}

		} else {

			Debug.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()));

		}

		if (avoirDonneesChargees()) {

			afficherDetail();

		}

	}

	protected void lierCollectionAPersonne(CollectionAPersonneListe personnes) {

		collection.setPersonnesLiees(personnes);

		personnesLieesChargementOk = true;

	}

	protected void lierCollectionAPublication(CollectionAPublicationListe publications) {

		collection.setPublicationsLiees(publications);

		publicationsLieesChargementOk = true;

	}

	protected void lierCollectionACommentaire(CollectionACommentaireListe commentaires) {

		collection.setCommentairesLiees(commentaires);

		commentairesLieesChargementOk = true;

	}

	private boolean avoirDonneesChargees() {

		boolean ok = false;

		if (collectionChargementOk && ontologieChargementOk && personnesLieesChargementOk && publicationsLieesChargementOk && commentairesLieesChargementOk) {

			ok = true;

		}

		return ok;

	}

	private void afficherDetail() {

		if (collection != null) {

			afficherEntete();

			afficherIdentification();

			afficherPersonne();

			afficherPublication();

			afficherDescription();

			afficherContenu();

			afficherInventaire();

			afficherCommentaire();

		}

		layout();

	}

	private void afficherEntete() {

		Params enteteParams = new Params();

		enteteParams.set("css_id", ComposantId.ZONE_DETAIL_ENTETE);

		enteteParams.set("css_meta", ComposantClass.META);

		enteteParams.set("i18n_id", i18nC.id());

		enteteParams.set("nom", collection.getNom());

		enteteParams.set("structure", collection.getStructureNom());

		enteteParams.set("id", collection.getId());

		enteteParams.set("guid", collection.getGuid());

		String eHtml = Format.substitute(enteteTpl, enteteParams);

		entete.getElement().setInnerHTML(eHtml);

	}

	private void afficherIdentification() {

		Params generalParams = new Params();

		generalParams.set("i18n_titre_identification", i18nC.titreAdministratif());

		generalParams.set("i18n_nom_alternatif", i18nC.intituleAlternatifCollection());

		generalParams.set("i18n_mere", i18nC.collectionMere());

		generalParams.set("i18n_type_ncd", i18nC.typeCollectionNcd());

		generalParams.set("i18n_type_depot", i18nC.typeDepot());

		generalParams.set("i18n_code", i18nC.codeAlternatifCollection());

		generalParams.set("i18n_cote", i18nC.cote());

		generalParams.set("i18n_general_collection_titre", i18nC.collectionGeneralTitre());

		generalParams.set("i18n_description", i18nC.description());

		generalParams.set("i18n_historique", i18nC.historique());

		generalParams.set("i18n_web", i18nC.siteWeb());

		generalParams.set("i18n_couverture_collection_titre", i18nC.collectionCouvertureTitre());

		generalParams.set("i18n_couverture_geo", i18nC.couvertureGeo());

		generalParams.set("i18n_periode", i18nC.periodeConstitutionDetail());

		String periode = "";

		if (!collection.getPeriodeConstitutionDebut().equals("0")) {

			periode = collection.getPeriodeConstitutionDebut();

		}

		if (!collection.getPeriodeConstitutionFin().equals("0")) {

			periode += " - "+collection.getPeriodeConstitutionFin();

		}

		generalParams.set("periode", periode);

		generalParams.set("i18n_specimen_type_titre", i18nC.collectionSpecimenTypeTitre());

		generalParams.set("i18n_specimen_type_presence", i18nC.specimenTypeCollectionDetail());

		generalParams.set("i18n_specimen_type_nombre", i18nC.nbreSpecimenTypeCollectionDetail());

		generalParams.set("i18n_specimen_type_classement", i18nC.classementSpecimenTypeCollectionDetail());

		String nomAlternatif = construireTxtTruck(collection.getNomAlternatif());

		String typeNcd = construireTxtListeOntologie(collection.getTypeNcd());

		String typeDepot = construireTxtListeOntologie(collection.getTypeDepot());

		String code = construireTxtTruck(collection.getCode());

		String urls = construireTxtTruck(collection.getUrls(), false);

		String couvertureGeo = construireTxtTruck(collection.getCouvertureLieu());

		String specimenTypePresence = construireTxtListeOntologie(collection.getSpecimenType());

		String specimenTypeNombrePrecision = construireTxtListeOntologie(collection.getSpecimenTypeNbrePrecision());

		String specimenTypeNombre = "";

		if (!collection.getSpecimenTypeNbre().equals("0") && !collection.getSpecimenTypeNbre().equals("")) {

			specimenTypeNombre = collection.getSpecimenTypeNbre()+" ("+specimenTypeNombrePrecision+")";

		}

		String specimenTypeClassement = construireTxtListeOntologie(collection.getSpecimenTypeClassement());

		generalParams.set("nom_alternatif", nomAlternatif);

		generalParams.set("mere", collection.getCollectionMereNom());

		generalParams.set("type_ncd", typeNcd);

		generalParams.set("type_depot", typeDepot);

		generalParams.set("code", code);

		generalParams.set("cote", collection.getCote());

		generalParams.set("description", collection.getDescription());

		generalParams.set("historique", collection.getHistorique());

		generalParams.set("web", urls);

		generalParams.set("couverture_geo", couvertureGeo);

		generalParams.set("specimen_type_presence", specimenTypePresence);

		generalParams.set("specimen_type_nombre", specimenTypeNombre);

		generalParams.set("specimen_type_classement", specimenTypeClassement);

		afficherOnglet(generalTpl, generalParams, generalOnglet);

	}

	private void afficherPersonne() {

		String tableauPersonneHtml = "";

		if (collection.getPersonnesLiees() != null && collection.getPersonnesLiees().size() > 0) {

			tableauPersonneHtml = construireTableauPersonnesLiees();

		}

		Params personneParams = new Params();

		personneParams.set("i18n_titre_personne", i18nC.collectionPersonneTitre());

		personneParams.set("tableau_personnes_liees", tableauPersonneHtml);

		afficherOnglet(personneTpl, personneParams, personneOnglet);

	}

	private String construireTableauPersonnesLiees() {

		Params contenuParams = new Params();

		contenuParams.set("i18n_relation", i18nC.typeRelationPersonneCollection());

		contenuParams.set("i18n_nom_complet", i18nC.personneNomComplet());

		contenuParams.set("i18n_prenom", i18nC.personnePrenom());

		contenuParams.set("i18n_nom", i18nC.personneNom());

		contenuParams.set("i18n_naissance_date", i18nC.personneDateNaissance());

		contenuParams.set("i18n_naissance_lieu", i18nC.personneLieuNaissance());

		contenuParams.set("i18n_etre_decede", i18nC.personneDeces());

		contenuParams.set("i18n_deces_date", i18nC.personneDateDeces());

		contenuParams.set("i18n_deces_lieu", i18nC.personneLieuDeces());

		String lignesPersonnel = "";

		if (collection.getPersonnesLiees() != null) {

			Iterator<String> it = collection.getPersonnesLiees().keySet().iterator();

			while (it.hasNext()) {

				CollectionAPersonne relationCollectionAPersonne = collection.getPersonnesLiees().get(it.next());

				Personne personne = relationCollectionAPersonne.getPersonne();

				String relation = construireTxtListeOntologie(relationCollectionAPersonne.getIdRole());

				String etreDecede = construireTxtListeOntologie(personne.getDeces());

				Params ligneParams = new Params();

				ligneParams.set("relation", relation);

				ligneParams.set("nom_complet", personne.getNomComplet());

				ligneParams.set("nom", personne.getNom());

				ligneParams.set("prenom", personne.getPrenom());

				ligneParams.set("naissance_date", personne.getNaissanceDate());

				ligneParams.set("naissance_lieu", personne.getNaissanceLieu());

				ligneParams.set("etre_decede", etreDecede);

				ligneParams.set("deces_date", personne.getDecesDate());

				ligneParams.set("deces_lieu", personne.getDecesLieu());

				lignesPersonnel += Format.substitute(lignePersonneLieeTpl, ligneParams);

			}

		}

		String cHtml = i18nC.nonRenseigne();

		if (!UtilString.isEmpty(lignesPersonnel)) {

			contenuParams.set("lignes", lignesPersonnel);

			cHtml = Format.substitute(tableauPersonnesLieesTpl, contenuParams);

		}

		return cHtml;

	}

	private void afficherPublication() {

		Params publicationParams = new Params();

		publicationParams.set("i18n_titre_publication", i18nC.collectionPublicationTitre());

		String tableauPublicationHtml = "";

		if (collection.getPersonnesLiees() != null && collection.getPersonnesLiees().size() > 0) {

			tableauPublicationHtml = construireTableauPublicationsLiees();

		}

		publicationParams.set("tableau_publications_liees", tableauPublicationHtml);

		afficherOnglet(publicationTpl, publicationParams, publicationOnglet);

	}

	private String construireTableauPublicationsLiees() {

		Params contenuParams = new Params();

		contenuParams.set("i18n_auteur", i18nC.publicationAuteurs());

		contenuParams.set("i18n_titre", i18nC.publicationTitre());

		contenuParams.set("i18n_revue", i18nC.publicationRevueCollection());

		contenuParams.set("i18n_editeur", i18nC.publicationEditeur());

		contenuParams.set("i18n_annee", i18nC.publicationDateParution());

		contenuParams.set("i18n_nvt", i18nC.publicationNvt());

		contenuParams.set("i18n_fascicule", i18nC.publicationFascicule());

		contenuParams.set("i18n_page", i18nC.publicationPage());

		contenuParams.set("i18n_source", i18nC.collectionPublicationSource());

		String lignesPublication = "";

		if (collection.getPublicationsLiees() != null) {

			Iterator<String> it = collection.getPublicationsLiees().keySet().iterator();

			while (it.hasNext()) {

				CollectionAPublication relationCollectionAPublication = collection.getPublicationsLiees().get(it.next());

				Publication publication = relationCollectionAPublication.getPublication();

				Params ligneParams = new Params();

				ligneParams.set("auteur", publication.getAuteur());

				ligneParams.set("titre", publication.getTitre());

				ligneParams.set("revue", publication.getCollection());

				ligneParams.set("editeur", publication.getNomEditeur());

				ligneParams.set("annee", publication.getAnneeParution());

				ligneParams.set("nvt", publication.getIndicationNvt());

				ligneParams.set("fascicule", publication.getFascicule());

				ligneParams.set("page", publication.getPages());

				ligneParams.set("source", relationCollectionAPublication.getSource() == "1" ? i18nC.oui() : i18nC.non());

				lignesPublication += Format.substitute(lignePublicationLieeTpl, ligneParams);

			}

		}

		String cHtml = i18nC.nonRenseigne();

		if (!UtilString.isEmpty(lignesPublication)) {

			contenuParams.set("lignes", lignesPublication);

			cHtml = Format.substitute(tableauPublicationsLieesTpl, contenuParams);

		}

		return cHtml;

	}

	private void afficherDescription() {

		Params descriptionParams = new Params();

		descriptionParams.set("i18n_titre_description", i18nC.collectionEtatGeneralEtNombreEchantillons());

		descriptionParams.set("i18n_type_botanique", i18nC.typeCollectionBotanique());

		descriptionParams.set("i18n_nbre_echantillon", i18nC.nbreEchantillon());

		descriptionParams.set("i18n_titre_unite_rangement", i18nC.collectionUniteRangementTitre());

		descriptionParams.set("i18n_etat_unite_rangement", i18nC.collectionUniteRangementEtatGeneralDetail());

		descriptionParams.set("i18n_titre_unite_base", i18nC.collectionUniteBaseTitre());

		descriptionParams.set("i18n_titre_conservation", i18nC.collectionTitreConservation());

		descriptionParams.set("i18n_type_papier", i18nC.typePapierConservationDetail());

		descriptionParams.set("i18n_conservation_methode", i18nC.methodeConservationDetail());

		descriptionParams.set("i18n_titre_etiquette", i18nC.collectionTitreEtiquette());

		descriptionParams.set("i18n_specimen_fixation_pourcent", i18nC.specimenFixationPourcent());

		descriptionParams.set("i18n_etiquette_fixation_pourcent", i18nC.etiquetteFixationPourcent());

		descriptionParams.set("i18n_specimen_fixation_methode", i18nC.specimenMethodeFixationDetail());

		descriptionParams.set("i18n_etiquette_fixation_methode_support", i18nC.etiquetteMethodeFixationSurSupportDetail());

		descriptionParams.set("i18n_etiquette_fixation_methode_specimen", i18nC.etiquetteMethodeFixationSurSpecimenDetail());

		descriptionParams.set("i18n_etiquette_type_ecriture", i18nC.typeEcritureDetail());

		descriptionParams.set("i18n_titre_traitement", i18nC.collectionTitreTraitement());

		descriptionParams.set("i18n_traitement", i18nC.collectionTraitementDetail());

		descriptionParams.set("i18n_traitement_poison", i18nC.collectionTraitementPoisonDetail());

		descriptionParams.set("i18n_traitement_insecte", i18nC.collectionTraitementInsecteDetail());

		descriptionParams.set("i18n_titre_etat_degradation", i18nC.collectionTitreEtatEtDegradation());

		descriptionParams.set("i18n_etat_general", i18nC.collectionEtatGeneralDetail());

		descriptionParams.set("i18n_degradation_specimen", i18nC.degradationSpecimenDetail());

		descriptionParams.set("i18n_degradation_presentation", i18nC.degradationPresentationDetail());

		descriptionParams.set("i18n_determination", i18nC.collectionDeterminationDetail());

		String typeBota = construireTxtListeOntologie(collection.getBotanique().getType());

		descriptionParams.set("type_botanique", typeBota);

		descriptionParams.set("nbre_echantillon", collection.getBotanique().getNbreEchantillon());

		CollectionBotanique collectionBotanique = collection.getBotanique();

		String etatUniteRangement = collectionBotanique.getUniteRangementEtat();

		descriptionParams.set("i18n_collection_cartons_herbiers", i18nC.collectionCartonsHerbiers());

		descriptionParams.set("i18n_nb_liasses", i18nC.collectionLiasses());

		descriptionParams.set("i18n_autres_unites_rangement", i18nC.collectionAutreUnitesRangement());

		String cartonsHerbiers = collectionBotanique.getNbCartonsHerbiers();

		if(!collectionBotanique.getNbCartonsHerbiers().trim().isEmpty() &&

		   ! collectionBotanique.getFormatCartonsHerbiers().trim().isEmpty()) {

			cartonsHerbiers += " - "+i18nC.format()+": ";

		}

		cartonsHerbiers += collectionBotanique.getFormatCartonsHerbiers();

		descriptionParams.set("nb_cartons_herbier", cartonsHerbiers);

		String liasses = collectionBotanique.getNbLiasses();

		if(!collectionBotanique.getNbLiasses().trim().isEmpty() &&

		   ! collectionBotanique.getFormatLiasses().trim().isEmpty()) {

			liasses += " - "+i18nC.format()+": ";

		}

		liasses += collectionBotanique.getFormatLiasses();

		descriptionParams.set("nb_liasses", liasses);

		descriptionParams.set("autres_unites_rangement", collectionBotanique.getAutresUnitesRangement().replaceAll("\r\n|\r|\n", ", "));

		descriptionParams.set("etat_unite_rangement", etatUniteRangement);

		descriptionParams.set("i18n_nb_planches_herbier", i18nC.collectionNbPlanchesHerbier());

		descriptionParams.set("i18n_nb_especes", i18nC.collectionNbEspeces());

		descriptionParams.set("nb_planches_herbier", collectionBotanique.getNbPlanchesHerbiers());

		descriptionParams.set("nb_especes", collectionBotanique.getNbEspeces());

		String typePapier = construireTxtListeOntologie(collectionBotanique.getConservationPapierType());

		String conservationMethode = construireTxtListeOntologie(collectionBotanique.getConservationMethode());

		descriptionParams.set("type_papier", typePapier);

		descriptionParams.set("conservation_methode", conservationMethode);

		String specimenFixationMethode = construireTxtListeOntologie(collectionBotanique.getSpecimenFixationMethode());

		String etiquetteFixationMethodeSupport = construireTxtListeOntologie(collectionBotanique.getEtiquetteFixationSupport());

		String etiquetteFixationMethodeSpecimen = construireTxtListeOntologie(collectionBotanique.getEtiquetteFixationSpecimen());

		String etiquetteTypeEcriture = construireTxtListeOntologie(collectionBotanique.getEtiquetteEcriture());

		descriptionParams.set("specimen_fixation_pourcent", collectionBotanique.getSpecimenFixationPourcent());

		descriptionParams.set("etiquette_fixation_pourcent", collectionBotanique.getEtiquetteFixationPourcent());

		descriptionParams.set("specimen_fixation_methode", specimenFixationMethode);

		descriptionParams.set("etiquette_fixation_methode_support", etiquetteFixationMethodeSupport);

		descriptionParams.set("etiquette_fixation_methode_specimen", etiquetteFixationMethodeSpecimen);

		descriptionParams.set("etiquette_type_ecriture", etiquetteTypeEcriture);

		String traitement = construireTxtListeOntologie(collectionBotanique.getTraitement());

		String traitementPoison = construireTxtListeOntologie(collectionBotanique.getTraitementPoison());

		String traitementInsecte = construireTxtListeOntologie(collectionBotanique.getTraitementInsecte());

		descriptionParams.set("traitement", traitement);

		descriptionParams.set("traitement_poison", traitementPoison);

		descriptionParams.set("traitement_insecte", traitementInsecte);

		String etatGeneral = collectionBotanique.getEtatGeneral();

		boolean valeurEstOntologie = false;

		boolean typeEstOntologie = true;

		boolean donneeEstOntologie = true;

		String degradationSpecimen = construireTxtListeOntologie(collectionBotanique.getDegradationSpecimen(), valeurEstOntologie, typeEstOntologie, donneeEstOntologie);

		String degradationPresentation = construireTxtListeOntologie(collectionBotanique.getDegradationPresentation(), valeurEstOntologie, typeEstOntologie, donneeEstOntologie);

		String determination = construireTxtListeOntologie(collectionBotanique.getDetermination());

		String[] ontoVal2 = OntologiesLocales.getListeBonMauvaisEtat().get(etatGeneral);

		//Coel.LogVersFirebug("ontoval2: " + ontoVal2);

		String eg = etatGeneral;

		if (ontoVal2 != null && ontoVal2.length > 0) {

			//Coel.LogVersFirebug("ontoval2[0]: " + ontoVal2[0]);

			eg = ontoVal2[0];

		}

		descriptionParams.set("etat_general", eg);

		descriptionParams.set("degradation_specimen", degradationSpecimen);

		descriptionParams.set("degradation_presentation", degradationPresentation);

		descriptionParams.set("determination", determination);

		afficherOnglet(descriptionTpl, descriptionParams, descriptionOnglet);

	}

	private void afficherContenu() {

		Params contenuParams = new Params();

		contenuParams.set("i18n_titre_nature", i18nC.collectionNatureTitre());

		contenuParams.set("i18n_nature", i18nC.natureVegetaleContenuDetail());

		contenuParams.set("i18n_specialite", i18nC.specialiteCollectionDetail());

		contenuParams.set("i18n_titre_classement", i18nC.collectionClassementTitre());

		contenuParams.set("i18n_classement_etat", i18nC.etatClassementCollectionDetail());

		contenuParams.set("i18n_classement", i18nC.annotationClassementCollectionDetail());

		contenuParams.set("i18n_titre_etiquette", i18nC.collectionEtiquetteTitre());

		contenuParams.set("i18n_etiquette_renseignement", i18nC.etiquetteRenseignementDetail());

		contenuParams.set("i18n_precision_localite", i18nC.precisionLocaliteDetail());

		contenuParams.set("i18n_precision_date", i18nC.precisionDateDetail());

		contenuParams.set("i18n_etiquette_annotation", i18nC.etiquetteAnnotationDetail());

		contenuParams.set("i18n_titre_integree", i18nC.collectionIntegreeTitre());

		contenuParams.set("i18n_collection_integration", i18nC.integreCollectionDetail());

		contenuParams.set("i18n_collection_integration_info", i18nC.infoIntegreCollectionDetail());

		CollectionBotanique collectionBotanique = collection.getBotanique();

		String nature = construireTxtListeOntologie(collectionBotanique.getNature());

		contenuParams.set("nature", nature);

		contenuParams.set("specialite", collectionBotanique.getSpecialite());

		String classementEtat = construireTxtListeOntologie(collectionBotanique.getClassementEtat());

		contenuParams.set("classement_etat", classementEtat);

		contenuParams.set("classement", collectionBotanique.getClassementAnnotation());

		String etiquetteRenseignements = "";

		HashMap<String,String> infos = CollectionFormContenu.parserEtiquetteRenseignement(collectionBotanique.getEtiquetteRenseignement());

		if (infos != null) {

			Iterator<String> it = infos.keySet().iterator();

			while (it.hasNext()) {

				String cle = it.next();

				if (cle.equals("AT")) {

					etiquetteRenseignements += i18nC.etiquetteAuteurCollection();

				} else if (cle.equals("F")) {

					etiquetteRenseignements += i18nC.etiquetteFamille();

				} else if (cle.equals("G")) {

					etiquetteRenseignements += i18nC.etiquetteGenre();

				} else if (cle.equals("SP")) {

					etiquetteRenseignements += i18nC.etiquetteSp();

				} else if (cle.equals("ASP")) {

					etiquetteRenseignements += i18nC.etiquetteAuteurSp();

				} else if (cle.equals("L")) {

					etiquetteRenseignements += i18nC.etiquetteLocalite();

				} else if (cle.equals("D")) {

					etiquetteRenseignements += i18nC.etiquetteDateRecolte();

				} else {

					etiquetteRenseignements += i18nC.inconnue();

				}

				if (it.hasNext()) etiquetteRenseignements += ": "+infos.get(cle)+"%, ";

				else etiquetteRenseignements += ": "+infos.get(cle)+"%.";

			}

		}

		String precisionLocalite = construireTxtListeOntologie(collectionBotanique.getPrecisionLocalite());

		String precisionDate = construireTxtListeOntologie(collectionBotanique.getPrecisionDate());

		contenuParams.set("etiquette_renseignement", etiquetteRenseignements);

		contenuParams.set("precision_localite", precisionLocalite);

		contenuParams.set("precision_date", precisionDate);

		contenuParams.set("etiquette_annotation", collectionBotanique.getAnnotationsDiverses());

		String collectionIntegration = construireTxtListeOntologie(collectionBotanique.getCollectionIntegre());

		String collectionIntegrationInfo = construireTxtListeOntologie(collectionBotanique.getCollectionIntegreInfo());

		contenuParams.set("collection_integration", collectionIntegration);

		contenuParams.set("collection_integration_info", collectionIntegrationInfo);

		afficherOnglet(contenuTpl, contenuParams, contenuOnglet);

	}

	private void afficherInventaire() {

		Params inventaireParams = new Params();

		inventaireParams.set("i18n_titre_inventaire", i18nC.collectionInventaireTitre());

		inventaireParams.set("i18n_existence", i18nC.existenceInventaireCollectionDetail());

		inventaireParams.set("i18n_participation_auteur", i18nC.auteurInventaireCollectionDetail());

		inventaireParams.set("i18n_forme", i18nC.formeInventaireCollectionDetail());

		inventaireParams.set("i18n_info", i18nC.infoInventaireCollectionDetail());

		inventaireParams.set("i18n_digital", i18nC.digitalInventaireCollectionDetail());

		inventaireParams.set("i18n_digital_pourcent", i18nC.pourcentDigitalInventaireCollectionDetail());

		inventaireParams.set("i18n_etat", i18nC.etatInventaireCollectionDetail());

		//DELETEME inventaireParams.set("i18n_type_donnee", i18nC.typeDonneeInventaireCollectionDetail());

		CollectionBotanique collectionBotanique = collection.getBotanique();

		String existence = OntologiesLocales.getValeurOntologie(OntologiesLocales.getListeOuiNonPeutEtre(), collectionBotanique.getInventaire());

		String participationAuteur = OntologiesLocales.getValeurOntologie(OntologiesLocales.getListeOuiNonPeutEtre(), collectionBotanique.getInventaireAuteur());

		String forme = construireTxtListeOntologie(collectionBotanique.getInventaireForme());

		String digital = construireTxtListeOntologie(collectionBotanique.getInventaireDigital());

		String digitalPourcent = collectionBotanique.getInventaireDigitalPourcent()+"%";

		String etat = construireTxtListeOntologie(collectionBotanique.getInventaireEtat());

		inventaireParams.set("existence", existence);

		inventaireParams.set("participation_auteur", participationAuteur);

		inventaireParams.set("forme", forme);

		inventaireParams.set("info", collectionBotanique.getInventaireInfo());

		inventaireParams.set("digital", digital);

		inventaireParams.set("digital_pourcent", digitalPourcent);

		inventaireParams.set("etat", etat);

		afficherOnglet(inventaireTpl, inventaireParams, inventaireOnglet);

	}

	private void afficherCommentaire() {

		String tableauCommentaireHtml = "";

		if (collection.getCommentairesLiees() != null && collection.getCommentairesLiees().size() > 0) {

			tableauCommentaireHtml = construireTableauCommentairesLiees();

		}

		Params personneParams = new Params();

		personneParams.set("i18n_titre_commentaire", i18nC.collectionCommentaireTitre());

		personneParams.set("tableau_commentaires_liees", tableauCommentaireHtml);

		afficherOnglet(commentaireTpl, personneParams, commentaireOnglet);

	}

	private String construireTableauCommentairesLiees() {

		Params contenuParams = new Params();

		contenuParams.set("i18n_type", i18nC.commentaireType());

		contenuParams.set("i18n_titre", i18nC.commentaireTitre());

		contenuParams.set("i18n_texte", i18nC.commentaireTexte());

		contenuParams.set("i18n_ponderation", i18nC.commentairePonderation());

		contenuParams.set("i18n_public", i18nC.commentairePublic());

		String lignesCommentaire = "";

		if (collection.getCommentairesLiees() != null) {

			Iterator<String> it = collection.getCommentairesLiees().keySet().iterator();

			while (it.hasNext()) {

				CollectionACommentaire relationCollectionACommentaire = collection.getCommentairesLiees().get(it.next());

				Commentaire commentaire = relationCollectionACommentaire.getCommentaire();

				String type = construireTxtListeOntologie(relationCollectionACommentaire.getType());

				String acces = (commentaire.etrePublic() ? i18nC.donneePublic() : i18nC.donneePrivee());

				Params ligneParams = new Params();

				ligneParams.set("type", type);

				ligneParams.set("titre", commentaire.getTitre());

				ligneParams.set("texte", commentaire.getTexte());

				ligneParams.set("ponderation", commentaire.getPonderation()+"/100");

				ligneParams.set("public", acces);

				lignesCommentaire += Format.substitute(ligneCommentaireLieeTpl, ligneParams);

			}

		}

		String cHtml = i18nC.nonRenseigne();

		if (!UtilString.isEmpty(lignesCommentaire)) {

			contenuParams.set("lignes", lignesCommentaire);

			cHtml = Format.substitute(tableauCommentairesLieesTpl, contenuParams);

		}

		return cHtml;

	}

	protected String getNomStructure() {

		String nomStructure = "";

		if (structure != null) {

			nomStructure = structure.getNom();

		} else {

			nomStructure = collection.getIdStructure();

		}

		return nomStructure;

	}

}