Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.composants;

import java.util.HashMap;

import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.composants.pagination.Proxy;
import org.tela_botanica.client.configuration.Configuration;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.aDonnee;

import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.data.ModelType;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.FieldEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.layout.ColumnData;
import com.extjs.gxt.ui.client.widget.layout.ColumnLayout;

public class ChampMultiValeursMultiTypesPaginable extends ChampMultiValeursPaginable implements Rafraichissable {

          //-------------//
         //  ATTRIBUTS  //
        //-------------//
        
        // Elements pour le champ 'types'
        ColumnData colonneChampTypes = null;
        ChampComboBoxRechercheTempsReelPaginable champTypesComboBox = null;
        int largeurChampTypes = 200;
        String displayNameChampTypes = "nom";
        
        // Elements pour gérer le type de valeurs que contient le champ
        Proxy proxyChampTypes = null;
        ModelType modeltypeChampTypes = null;

        // Variables de traitement
        HashMap<Integer, String> tempMapValeurs = null;
        
          //-------------//
         //   METHODES  //
        //-------------//

        /*--------------
          Constructeur 
        --------------*/
        public ChampMultiValeursMultiTypesPaginable(String label, int largeurTotale, boolean estCombobox, ModelType modeltypeChampValeur, Proxy proxyChampValeur, String displayNameChampValeur, ModelType modeltypeChampTypes, Proxy proxyChampTypes, String displayNameChampTypes) {
                super(label, largeurTotale, estCombobox, modeltypeChampValeur, proxyChampValeur, displayNameChampValeur);
                
                this.proxyChampTypes = proxyChampTypes;
                this.modeltypeChampTypes = modeltypeChampTypes;
                this.displayNameChampTypes = displayNameChampTypes;
                
                initialiserChampMultiValeursMultiTypesPaginable(label);
        }

        /*------------
          Accesseurs 
        ------------*/
        
         //------------//
        //    Get     //------------------------------------------------------------
        
        public ChampComboBoxRechercheTempsReelPaginable getChampTypesComboBox() {
                return this.champTypesComboBox;
        }
        
         //------------//
        //    Set     //------------------------------------------------------------
        
        @Override
        public void setLargeurTotale(int largeurTotale) {
                this.largeurTotale = largeurTotale;
                largeurChampValeur = largeurTotale - largeurBouton - largeurChampTypes;
        }
        
        /*-------------------------------------------
          Méthodes protégées et méthodes publiques 
        --------------------------------------------*/
        
        @Override
        public void rafraichir(Object nouvellesDonnees) {
                super.rafraichir(nouvellesDonnees);
                if (nouvellesDonnees instanceof ValeurListe) {
                        Valeur v = ((ValeurListe)nouvellesDonnees).toList().get(0);
                        ajouterValeur(tempMapValeurs.get(Integer.parseInt(v.getId())), v.getNom(), v.getId());
                }
        }
        
        @Override
        protected void ajouterValeur(final String texte, final String type, final String idType) {
                
                LayoutContainer colonneConteneur = new LayoutContainer();
                colonneConteneur.setLayout(new ColumnLayout());
                valeurs.put(idType + aDonnee.SEPARATEUR_TYPE_VALEUR + texte, colonneConteneur);
                
                Text champType = new Text();
                champType.setText(type + " : ");
                champType.setWidth(largeurChampTypes);
                colonneConteneur.add(champType, new ColumnData(largeurChampTypes));
                
                Text champValeur = new Text();
                champValeur.setText(texte);
                champValeur.setWidth(largeurChampTypes);
                colonneConteneur.add(champValeur, new ColumnData(largeurChampTypes));
                
                Button supprimerBouton = new Button();
                supprimerBouton.setIcon(Images.ICONES.supprimer());
                supprimerBouton.setText(boutonSupprimerLabel);
                supprimerBouton.setData("valeur", idType + aDonnee.SEPARATEUR_TYPE_VALEUR + texte);
                
                supprimerBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        public void componentSelected(ButtonEvent ce) {
                                String valeur = ce.getComponent().getData("valeur");
                                LayoutContainer valeurLayout = valeurs.get(valeur);
                                principalLayout.remove(valeurLayout);
                                valeurs.remove(valeur);
                                supprimerValeurDuRecapitulatif(valeur);
                                actualiserLayoutGlobal();
                        }
                });
                colonneConteneur.add(supprimerBouton, new ColumnData(largeurBouton));
                
                // Ajout du layout de la valeur au layout principal
                principalLayout.add(colonneConteneur);
                
                // Ajout de la valeur au champ récapitulatif des valeurs ajoutées             
                ajouterValeurAuRecapitulatif(texte, idType);
                
                reinitialiserChamp();
                actualiserLayoutGlobal();
        }

        @Override
        public void peupler(String chaineExistante) {
                
                if (valeurs.size() > 0) {
                        reinitialiser();
                }
                if (chaineExistante != null && !chaineExistante.trim().equals("")) {
                        
                        String[] valeurs = chaineExistante.split(aDonnee.SEPARATEUR_VALEURS);
                        for (int i = 0; i < valeurs.length; i++) {
                                String[] idEtValeur = valeurs[i].split(aDonnee.SEPARATEUR_TYPE_VALEUR);
                                if (idEtValeur.length == 2) {
                                        String idType = idEtValeur[0];
                                        String idValeur = idEtValeur[1];
                                        
                                        // Champ Valeur
                                        if (idType.matches("[0-9]+")) {
                                                tempMapValeurs.put(Integer.parseInt(idType), idValeur);
                                        } else {
                                                tempMapValeurs.put(((Configuration)(Registry.get(RegistreId.CONFIG))).getListeId(idType), idValeur);
                                        }
        
                                        // Champ Types
                                        mediateur.obtenirValeurEtRafraichir(this,"*", idType, null);
                                } else {
                                        InfoLogger.display("Erreur", "ChampMultiValeursMultiTypesPaginable. Erreur dans le split de "+chaineExistante, true);
                                }
                        }
                }
        }

        
        /*------------------
          Méthodes privées 
        ------------------*/
        
        private void initialiserChampMultiValeursMultiTypesPaginable(String label) {
                setLargeurTotale(largeurTotale);
                tempMapValeurs = new HashMap<Integer,String>();
                creerChampMultiValeursMultiTypes();
        }

        private void creerChampMultiValeursMultiTypes() {
                
                /* Creation du champ Types */           
                champTypesComboBox = new ChampComboBoxRechercheTempsReelPaginable(proxyChampTypes, modeltypeChampTypes, displayNameChampTypes);
                champTypesComboBox.setWidth(largeurChampTypes);
                champTypesComboBox.getCombo().setEmptyText("Type...");
                
                champTypesComboBox.addListener(Events.Select, new Listener<FieldEvent>() {
                        public void handleEvent(FieldEvent fe) {

                        }
                });

                /* Placement des éléments dans le conteneur */
                // le champ "types" doit être graphiquement placé avant les autres champs,
                // on doit donc retirer ces derniers avant d'insérer le champ "types"          
                colonneConteneur.removeAll();
                colonneConteneur.setWidth(largeurTotale);
                colonneChampTypes = new ColumnData(largeurChampTypes); 
                colonneChampTypes.setWidth(largeurChampTypes);
                colonneConteneur.add(champTypesComboBox, colonneChampTypes);            
                if (champValeurEstComboBox) {
                        champValeurComboBox.setWidth(largeurChampValeur);
                        colonneChampValeur.setWidth(largeurChampValeur);
                        colonneConteneur.add(champValeurComboBox, colonneChampValeur);                  
                } else {
                        champValeurTxt.setWidth(largeurChampValeur);
                        colonneChampValeur.setWidth(largeurChampValeur);
                        colonneConteneur.add(champValeurTxt, colonneChampValeur);
                }
                ajouterBouton.setWidth(largeurBouton);
                colonneBoutonAjouter.setWidth(largeurBouton);
                colonneConteneur.add(ajouterBouton, colonneBoutonAjouter);

                /* Modification de l'écouteur du bouton Ajouter */
                ajouterBouton.removeAllListeners();
                ajouterBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        public void componentSelected(ButtonEvent ce) {
                                // récupération de la valeur du champ "Valeur"
                                String valeurChamp = "";
                                if (champValeurEstComboBox) {
                                        if (champValeurComboBox.getValeur() != null) {
                                                Valeur val = new Valeur(champValeurComboBox.getValeur());
                                                valeurChamp = val.getNom();
                                        }
                                } else {
                                        valeurChamp = champValeurTxt.getValue();
                                }
                                
                                // validation de la valeur avant ajout
                                if ((valeurChamp == null) || valeurChamp.trim().equals("") || valeurChamp.trim().equals(valeurParDefaut))       {
                                        MessageBox.alert(titreErreur, valeurVideMsg, null);
                                } else if (valeurs.get(valeurChamp) != null){
                                        MessageBox.alert(titreErreur, valeurIdentiqueMsg, null);                                                        
                                } else {
                                        if (validationMasque != null && !valeurChamp.matches(validationMasque))         {
                                                MessageBox.alert(titreErreur, valeurNonValideMsg, null);
                                        } else { // VALIDATION OK
                                                Valeur type = new Valeur(champTypesComboBox.getValeur());
                                                String typeNomStr = type.getNom();
                                                String typeIdStr = type.getId();

                                                if (typeIdStr.trim().equals(""))        {
                                                        MessageBox.alert(Mediateur.i18nM.titreErreurSaisie(), Mediateur.i18nM.typeChampMulti(), null);
                                                } else {
                                                        ajouterValeur(valeurChamp, typeNomStr, typeIdStr);
                                                }
                                        }
                                }
                        }
                });
        }
        
        private void ajouterValeurAuRecapitulatif(String texte, String id) {
                String texteRecapitulatif = "";
                if (champRecapitulatif.getValue() != null)      {
                        texteRecapitulatif = champRecapitulatif.getValue();
                }
                texteRecapitulatif += id + aDonnee.SEPARATEUR_TYPE_VALEUR + texte + aDonnee.SEPARATEUR_VALEURS;
                champRecapitulatif.setValue(texteRecapitulatif);
        }
}