Subversion Repositories eFlore/Applications.coel

Rev

Blame | Last modification | View Log | RSS feed 

package org.tela_botanica.client.vues;

import java.util.List;

import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampMultiValeurs;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.aDonneeListe;

import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.HiddenField;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.NumberFormat;

public class CollectionFormGeneral extends FormulaireOnglet implements Rafraichissable {
        
        private HiddenField<String> idCollectionChp;
        
        private FieldSet descriptionFieldSet;
        private ListStore<Valeur> typesCollectionStore;
        private ListStore<Valeur> typeCollectionBotaStore;
        private ListStore<Valeur> typeDepotStore;
        private ComboBox<Valeur> typeDepotCombo;
        private ComboBox<Valeur> typesCollectionBotaCombo;
        private ComboBox<Valeur> typesCollectionCombo;
        
        private ListStore<Projet> projetsStore;
        private ComboBox<Projet> projetsCombo;

        private ComboBox<Structure> structuresCombo;

        private ListStore<Structure> structuresStore;

        private ComboBox<Collection> collectionsCombo;

        private ListStore<Collection> collectionsStore;

        public CollectionFormGeneral(Formulaire formulaireCourrant) {
                initialiserOnglet(formulaireCourrant);
                setId("general");
                setText(Mediateur.i18nC.collectionGeneral());
                
                creerChampsCache();
                creerFieldsetLiaison();
                creerFieldsetAdministratif();
                creerFieldsetDescription();
        }

        private void creerChampsCache() {
                // Champs cachés
                idCollectionChp = new HiddenField<String>();
                this.add(idCollectionChp);
        }
        
        private void creerFieldsetLiaison() {
                // Fieldset LIAISON
                FieldSet liaisonFieldSet = new FieldSet();
                liaisonFieldSet.setHeading(i18nC.liaisonTitreCollection());
                liaisonFieldSet.setCollapsible(true);
                liaisonFieldSet.setLayout(Formulaire.creerFormLayout(150, LabelAlign.LEFT));
                
                projetsStore = new ListStore<Projet>();
                projetsCombo = new ComboBox<Projet>();
                projetsCombo.setTabIndex(tabIndex++);
                projetsCombo.setFieldLabel(i18nC.projetChamp());
                projetsCombo.setDisplayField("nom");
                projetsCombo.setForceSelection(true);
                projetsCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (projetsStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });
                projetsCombo.setTriggerAction(TriggerAction.ALL);
                projetsCombo.setStore(projetsStore);
                liaisonFieldSet.add(projetsCombo, new FormData(450, 0));
                mediateur.selectionnerProjets(this);
                
                structuresStore = new ListStore<Structure>();
                structuresCombo = new ComboBox<Structure>();
                structuresCombo.setTabIndex(tabIndex++);
                structuresCombo.setFieldLabel(i18nC.lienStructureCollection());
                structuresCombo.setDisplayField("nom");
                structuresCombo.setForceSelection(true);
                structuresCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (structuresStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });
                structuresCombo.setTriggerAction(TriggerAction.ALL);
                structuresCombo.setStore(structuresStore);
                liaisonFieldSet.add(structuresCombo, new FormData(450, 0));
                mediateur.selectionnerStructure(this, null);
                
                collectionsStore = new ListStore<Collection>();
                collectionsCombo = new ComboBox<Collection>();
                collectionsCombo.setTabIndex(tabIndex++);
                collectionsCombo.setFieldLabel(i18nC.lienMereCollection());
                collectionsCombo.setDisplayField("nom");
                collectionsCombo.setForceSelection(true);
                collectionsCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (collectionsStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                GWT.log("Validation : "+field.getRawValue()+"-"+field.getValue(), null);
                                return retour;
                        }
                });
                collectionsCombo.setTriggerAction(TriggerAction.ALL);
                collectionsCombo.setStore(collectionsStore);
                liaisonFieldSet.add(collectionsCombo, new FormData(450, 0));
                mediateur.selectionnerCollection(this, null);
                
                this.add(liaisonFieldSet);
        }
        
        private void creerFieldsetAdministratif() {
                // Fieldset ADMINISTRATIF
                FieldSet administratifFieldSet = new FieldSet();
                administratifFieldSet.setHeading(i18nC.collectionGeneralTitre());
                administratifFieldSet.setCollapsible(true);
                administratifFieldSet.setLayout(Formulaire.creerFormLayout(150, LabelAlign.LEFT));
                
                typesCollectionStore = new ListStore<Valeur>();
                typesCollectionCombo = new ComboBox<Valeur>();
                typesCollectionCombo.setTabIndex(tabIndex++);
                typesCollectionCombo.setFieldLabel(i18nC.typeCollectionNcd());
                typesCollectionCombo.setDisplayField("nom");
                typesCollectionCombo.setForceSelection(true);
                typesCollectionCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (typesCollectionStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });
                typesCollectionCombo.setTriggerAction(TriggerAction.ALL);
                typesCollectionCombo.setStore(typesCollectionStore);
                administratifFieldSet.add(typesCollectionCombo, new FormData(250, 0));
                mediateur.obtenirListeValeurEtRafraichir(this, "typeCollectionNcd");
                
                typeCollectionBotaStore = new ListStore<Valeur>();
                typesCollectionBotaCombo = new ComboBox<Valeur>();
                typesCollectionBotaCombo.setTabIndex(tabIndex++);
                typesCollectionBotaCombo.setFieldLabel(i18nC.typeCollectionBotanique());
                typesCollectionBotaCombo.setDisplayField("nom");
                typesCollectionBotaCombo.setForceSelection(true);
                typesCollectionBotaCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (typeCollectionBotaStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });
                typesCollectionBotaCombo.setTriggerAction(TriggerAction.ALL);
                typesCollectionBotaCombo.setStore(typeCollectionBotaStore);
                administratifFieldSet.add(typesCollectionBotaCombo, new FormData(250, 0));
                mediateur.obtenirListeValeurEtRafraichir(this, "typeCollectionBota");
                
                typeDepotStore = new ListStore<Valeur>();
                typeDepotCombo = new ComboBox<Valeur>();
                typeDepotCombo.setTabIndex(tabIndex++);
                typeDepotCombo.setFieldLabel(i18nC.typeDepot());
                typeDepotCombo.setDisplayField("nom");
                typeDepotCombo.setForceSelection(true);
                typeDepotCombo.setValidator(new Validator() {
                        @Override
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (typeDepotStore.findModel("nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });
                typeDepotCombo.setTriggerAction(TriggerAction.ALL);
                typeDepotCombo.setStore(typeCollectionBotaStore);
                administratifFieldSet.add(typeDepotCombo, new FormData(250, 0));
                mediateur.obtenirListeValeurEtRafraichir(this, "typeDepot");
                
                TextField<String> coteChp = new TextField<String>();
                coteChp.setTabIndex(tabIndex++);
                coteChp.setFieldLabel(i18nC.cote());
                administratifFieldSet.add(coteChp, new FormData(450, 0));
                
                NumberField nbreEchantillonChp = new NumberField(); 
                nbreEchantillonChp.setFieldLabel(i18nC.nbreEchantillon());
                nbreEchantillonChp.setToolTip(i18nC.nbreEchantillonInfo());
                nbreEchantillonChp.setFormat(NumberFormat.getFormat("#"));
                nbreEchantillonChp.setToolTip(i18nC.champNumerique());
                administratifFieldSet.add(nbreEchantillonChp);
                
                TextField<String> nomChp = new TextField<String>();
                nomChp.setTabIndex(tabIndex++);
                nomChp.setFieldLabel(i18nC.nomCollection());
                nomChp.setAllowBlank(false);
                nomChp.getMessages().setBlankText(i18nC.champObligatoire());
                administratifFieldSet.add(nomChp, new FormData(450, 0));
                
                ChampMultiValeurs nomsAlternatifsChp = new ChampMultiValeurs(i18nC.intituleAlternatifCollection());
                administratifFieldSet.add(nomsAlternatifsChp);
                                
                ChampMultiValeurs codesAlternatifsChp = new ChampMultiValeurs(i18nC.codeAlternatifCollection());
                administratifFieldSet.add(codesAlternatifsChp);
                
                this.add(administratifFieldSet);
        }
        
        private void creerFieldsetDescription() {
                // Fieldset DESCRIPTION
                descriptionFieldSet = new FieldSet();
                descriptionFieldSet.setHeading(i18nC.collectionDescriptionTitre());
                descriptionFieldSet.setCollapsible(true);
                descriptionFieldSet.setLayout(Formulaire.creerFormLayout(150, LabelAlign.LEFT));

                TextArea descriptionChp = new TextArea();
                descriptionChp.setFieldLabel(i18nC.description());
                descriptionFieldSet.add(descriptionChp, new FormData(550, 0));
                
                TextArea descriptionSpecialisteChp = new TextArea();
                descriptionSpecialisteChp.setFieldLabel(i18nC.descriptionSpecialiste());
                descriptionFieldSet.add(descriptionSpecialisteChp, new FormData(550, 0));
                
                TextArea historiqueChp = new TextArea();
                historiqueChp.setFieldLabel(i18nC.historique());
                descriptionFieldSet.add(historiqueChp, new FormData(550, 0));
                
                ChampMultiValeurs urlsChp = new ChampMultiValeurs(i18nC.urlsCollection());
                descriptionFieldSet.add(urlsChp);

                this.add(descriptionFieldSet);
        }
        
        public void rafraichir(Object nouvellesDonnees) {
                if (nouvellesDonnees instanceof ValeurListe) {
                        ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
                        rafraichirValeurListe(listeValeurs);
                } else if (nouvellesDonnees instanceof ProjetListe) {
                        ProjetListe projets = (ProjetListe) nouvellesDonnees;
                        rafraichirComboBox(projets, projetsStore, projetsCombo);
                } else if (nouvellesDonnees instanceof StructureListe) {
                        StructureListe structures = (StructureListe) nouvellesDonnees;
                        rafraichirComboBox(structures, structuresStore, structuresCombo);
                } else if (nouvellesDonnees instanceof CollectionListe) {
                        CollectionListe collections = (CollectionListe) nouvellesDonnees;
                        rafraichirComboBox(collections, collectionsStore, collectionsCombo);
                } else {
                        GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
                }
        }
        
        private void rafraichirValeurListe(ValeurListe listeValeurs) {
                if (listeValeurs.getId().equals(config.getListeId("typeCollectionNcd"))) {
                        rafraichirComboBox(listeValeurs, typesCollectionStore, typesCollectionCombo);
                } else if (listeValeurs.getId().equals(config.getListeId("typeCollectionBota"))) {
                        rafraichirComboBox(listeValeurs, typeCollectionBotaStore, typesCollectionBotaCombo);
                } else if (listeValeurs.getId().equals(config.getListeId("typeDepot"))) {
                        rafraichirComboBox(listeValeurs, typeDepotStore, typeDepotCombo);
                } else {
                        GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
                }
        }
        
        @SuppressWarnings({"unchecked"})
        private void rafraichirComboBox(aDonneeListe<?> listeValeurs, ListStore store, ComboBox combo) {
                List<?> liste = listeValeurs.toList();
                if (liste.size() > 0) {
                        store.removeAll();
                        store.add(liste);
                        store.sort("nom", SortDir.ASC);
                        combo.setStore(store);
                }
        }

}