Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.util.autocompletion;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.tela_botanica.client.util.Util;

import com.google.gwt.core.client.Callback;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.dom.client.KeyDownEvent;
import com.google.gwt.event.dom.client.KeyDownHandler;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.http.client.URL;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.MultiWordSuggestOracle;
import com.google.gwt.user.client.ui.SuggestBox;
import com.google.gwt.user.client.ui.SuggestBox.DefaultSuggestionDisplay;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.SuggestOracle;
import com.google.gwt.user.client.ui.SuggestOracle.Suggestion;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.layout.FitLayout;

@SuppressWarnings("unchecked")
public abstract class AutoCompletionComboBox extends Panel {
                
        Label label = null;
        MultiWordSuggestOracle msu = null;
        SuggestBox suggestions = null;
        DefaultSuggestionDisplay sgd = null;
        
        Callback<String, String> surCopierColler = null;
        
        SuggestOracle.Request requeteOracle;
    SuggestOracle.Callback callBackOracle;
    
        Timer suggestionTimer = null;
    int tempsAvantRequete = 500;
    
    Map<String, String> possibilites = null;
    
    String urlRequete = "";
        
        public AutoCompletionComboBox(String nomLabel, String urlRequete) {
                
                this.setStyleName("champAutoComplete");
                
                this.label = new Label(nomLabel+":");
                this.urlRequete = urlRequete;
                
                sgd = new SuggestBox.DefaultSuggestionDisplay();
                msu = new MultiWordSuggestOracle() {
                        @Override
                        public void requestSuggestions(Request request, Callback callback) {
                                List<MultiWordSuggestion> retenus = new ArrayList<MultiWordSuggestion>();
                                Iterator<String> it = possibilites.keySet().iterator();
                            while (it.hasNext()) {
                                String cle = it.next();
                                String cleAffichee = preTraiterValeurAvantAffichage(cle);
                                        MultiWordSuggestion muWoSug = new MultiWordSuggestion(cle, cleAffichee);
                                        retenus.add(muWoSug);
                            }

                                Response reponse = new Response(retenus);
                                callback.onSuggestionsReady(request, reponse);
                        }               
                };

                suggestions = new SuggestBox(msu, new TextBox(), sgd) {
                        public void onBrowserEvent(Event event) {
                            switch (event.getTypeInt()) {
                                case Event.ONPASTE: {
                                        if(surCopierColler != null) {
                                                surCopierColler.onSuccess(suggestions.getValueBox().getValue());
                                        }
                                }
                                break;
                                default:
                                        // WTF: Curieux bloc qui est nécessaire car si on appelle pas super.onBrowserEvent
                                        // aucun évènement ne fonctionne et si on le fait, cela génère des nullPointerException
                                        // donc on transige en l'appelant dans un try catch
                                        try {
                                                super.onBrowserEvent(event);
                                        } catch (Exception e) {
                                                // à priori rien à faire
                                        }
                            }
                            
                        }
                };
                
                suggestions.setAutoSelectEnabled(false);
                setLayout(new FitLayout());
                add(label);
                add(suggestions);
                gererEvenements();
        }
        
        public void gererEvenements() {
                suggestions.addKeyDownHandler(new KeyDownHandler() {

                    @Override
                    public void onKeyDown(KeyDownEvent event) {         
                        // Lorsque la liste de suggestions est ouverte, une frappe sur entrée selectionne la valeur
                        // Si elle est fermée, elle déclenche la fonction abstraite de validation (utile pour les champs
                        // du genre station, milieu etc... et la saisie d'obs rapide
                                if(event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {    
                                        if((sgd == null || !sgd.isSuggestionListShowing())) {
                                                onValidationSaisie();
                                                Util.LogVersFirebug("je passe ici");
                                                event.stopPropagation();
                                                return;
                                        } else {
                                                Util.LogVersFirebug("je passe là");
                                                // Dans les autres cas, un appui sur entrée ne doit pas redéclencher l'autcomplétion
                                                return;
                                        }
                                }
                                
                                if(event.getNativeKeyCode() == KeyCodes.KEY_DOWN) {
                                        // Un appui sur flèche bas permet de demander toute la liste
                                        if(!sgd.isSuggestionListShowing()) {
                                                requeteToutesSuggestions();
                                        }
                                }
                                
                                // Tout autre frappe d'un caractère "normal" déclenche le timer d'autocomplétion
                                if(!KeyDownEvent.isArrow(event.getNativeKeyCode())) {
                                        gererTimer();
                                }
                    }

                });
                
                requeteOracle = new SuggestOracle.Request();
                callBackOracle = new SuggestOracle.Callback() {

                        public void onSuggestionsReady(SuggestOracle.Request request, SuggestOracle.Response response) {
                                suggestions.showSuggestionList();
                        }
            };
            
            suggestions.addSelectionHandler(new SelectionHandler<SuggestOracle.Suggestion>(){
                        @Override
                        public void onSelection(SelectionEvent<Suggestion> event) {
                                onSelectionValeur();
                        }
                });
            
            suggestions.addValueChangeHandler(new ValueChangeHandler<String>() {
                        @Override
                        public void onValueChange(ValueChangeEvent<String> event) {
                                onModificationValeur();
                        }
                });
            
            surCopierColler = new Callback<String, String>() {          
                        @Override
                        public void onSuccess(String result) {
                                gererTimer();
                        }
                        
                        @Override
                        public void onFailure(String reason) {
                                // rien à faire ça n'échoue jamais
                        }
                };
                
                addListener(new PanelListenerAdapter() {
                        
                        @Override
                        public void onResize(BoxComponent component, int adjWidth, int adjHeight,
                                        int rawWidth, int rawHeight) {
                                redimensionner(rawWidth);
                        }
                });
        }
        
        public void redimensionner(final int largeur) {
                suggestions.setWidth((largeur - label.getOffsetWidth() - 13)+"px");
        }
        
        public void gererTimer() {
                if(suggestionTimer == null) {
                        suggestionTimer = new Timer() {
                                public void run() {
                                        requeteSuggestions();
                                }       
                        };                                      
                        suggestionTimer.schedule(tempsAvantRequete);
                } else {
                        suggestionTimer.schedule(tempsAvantRequete);
                }
        }
        
        public void setTempsAvantRequete(int temps) {
                tempsAvantRequete = temps;
        }
        
        public int getTempsAvantRequete(int temps) {
                return tempsAvantRequete;
        }
        
        public void requeteToutesSuggestions() {
                // Cette méthode permet de demander l'autocomplétion même si 
                // la valeur saisie est vide (cas de l'appui sur flèche bas)
                envoyerRequeteSuggestions("*");
        }
        
        public void requeteSuggestions() {
                // Suppression des espaces et caractères inutiles
                String valeur = suggestions.getValue().trim().isEmpty() ? null : suggestions.getValue().trim(); 
                
                // ceci permet au composant qui utilise l'autocomplétion
                // d'annuler une requete et également d'éviter de faire une requête lors du vidage du champ
                if(valeur == null) {
                        return;
                }
                envoyerRequeteSuggestions(valeur);
        }
        
        private void envoyerRequeteSuggestions(final String valeur) {
                final String urlRequeteFmt = preTraiterUrlRequete(urlRequete, valeur);  
                RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, urlRequeteFmt) ;
                try {           
                        rb.sendRequest(null, new RequestCallback() {
                                public void onError(final Request request, final Throwable exception) {
                                        // TODO Auto-generated method stub              
                                }

                                public void onResponseReceived(final Request request,
                                                final Response response) {
                                        surReponseRequete(valeur, response);
                                }
                        }) ;

                } catch (RequestException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        
        public void surReponseRequete(String requete, Response response) {
                possibilites = parserResultatRequete(response);
                msu.clear();
                Iterator<String> it = possibilites.keySet().iterator();
            while (it.hasNext()) {
                msu.add(possibilites.get(it.next()));
            }
                        
                requeteOracle.setQuery(requete);
                if(requete.equals("*")) {
                        // TODO : il y a peut être une méthode plus simple
                        // mais ceci permet d'afficher les suggestions en cas d'appui
                        // sur bas lorsque la liste est vide
                        msu.setDefaultSuggestionsFromText(possibilites.values());       
                        SuggestOracle.Request rq = new SuggestOracle.Request();
                        rq.setQuery(null);
                        msu.requestDefaultSuggestions(rq, callBackOracle);
                } else {
                        msu.requestSuggestions(requeteOracle, callBackOracle);  
                }
        }
        
        public String getText() {
                return suggestions.getText();
        }
        
        public void setText(String texte) {
                suggestions.setText(texte);
        }
        
        public String getRawValue() {
                return suggestions.getText();
        }

        public String getValue() {
                return suggestions.getValue();
        }
        
        public void setValue(String valeur) {
                suggestions.setText(valeur);
        }
        
        public void reset() {
                suggestions.setValue("");
        }
        
        public void setTabIndex(int index) {
                suggestions.setTabIndex(index);
        }
        
        public String getLabelText() {
                return label.getText();
        }
        
        public int getFieldWidth() {
                return suggestions.getOffsetWidth();
        }
        
        public int getLabelWidth() {
                return label.getOffsetWidth();
        }
        
        public void agrandirChamp(int largeur) {
                suggestions.setWidth(largeur+"px");
        }
        
        protected String preTraiterValeurAvantAffichage(String cle) {
                return possibilites.get(cle);
        }
        protected String preTraiterUrlRequete(String urlRequete, String valeur) {
                return urlRequete+URL.encodeQueryString(valeur);
        }
        protected abstract Map<String, String> parserResultatRequete(Response response);        
        protected abstract void onModificationValeur();
        protected abstract void onSelectionValeur();
        protected abstract void onValidationSaisie();
}