Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.composants.fenetreoverlay;

import org.tela_botanica.del.client.composants.fenetreoverlay.FenetreOverlayDefilantePresenteur.Vue;

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Element;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.event.dom.client.HasKeyDownHandlers;
import com.google.gwt.event.logical.shared.ResizeEvent;
import com.google.gwt.event.logical.shared.ResizeHandler;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.DOM;
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.Button;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.FocusPanel;
import com.google.gwt.user.client.ui.HasVisibility;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.IsWidget;
import com.google.gwt.user.client.ui.UIObject;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;

public class FenetreOverlayDefilanteVue extends Composite implements Vue {

        interface MyUiBinder extends UiBinder<Widget, FenetreOverlayDefilanteVue> {}
        
        @UiField
        VerticalPanel conteneurGlobal;

        @UiField
        FocusPanel overlay;
        
        @UiField
        FocusPanel overlayContenu;

        @UiField
        Button boutonFermer, boutonSuivant, boutonPrecedent;
        
        @UiField 
        HorizontalPanel conteneurOverlayContenu;
        
        private int hauteurContenu = 0;
        private int largeurContenu = 0;
        
        // contiennent les coordonnées actuelles du scroll 
        // pour le rétablir une fois la fenêtre fermée
        private int topFenetre = 0;
        private int gaucheFenetre = 0;
        
        private Timer timerPlacement = null;
        
        public FocusPanel getOverlay() {
                return overlay;
        }

        public FocusPanel getOverlayContenu() {
                return overlayContenu;
        }
        
        @Override
        public HasClickHandlers getOverlayHasClickHandlers() {
                return overlayContenu;
        }

        public Button getBoutonFermer() {
                return boutonFermer;
        }

        public Button getBoutonSuivant() {
                return boutonSuivant;
        }

        public Button getBoutonPrecedent() {
                return boutonPrecedent;
        }

        private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);

        public FenetreOverlayDefilanteVue() {
                initWidget(uiBinder.createAndBindUi(this));
                boutonFermer.setStyleName("fermerOverlay");
                boutonPrecedent.setStyleName("precedentOverlay");
                boutonSuivant.setStyleName("suivantOverlay");
                                
                Window.addResizeHandler(new ResizeHandler() {
                        @Override
                        public void onResize(ResizeEvent event) {
                                gererDimensionsEtPositionnerBoutons();
                        }
                });
        }
        
        @Override
        public HasKeyDownHandlers getConteneurGlobal() {
                return overlayContenu;
        }

        @Override
        public HasVisibility getOverlayVisibility() {
                return overlay;
        }

        @Override
        public HasVisibility getOverlayContenuVisibility() {
                return overlayContenu;
        }

        @Override
        public HasWidgets getOverlayContenuHasWidgets() {
                return overlayContenu;
        }

        @Override
        public void setStyleOverlay(String style) {
                overlay.setStyleName(style);
        }

        @Override
        public void setStyleOverlayContenu(String style) {
                overlayContenu.setStyleName(style);
        }

        @Override
        public void setOverlayContenu(IsWidget w) {
                overlayContenu.clear();
                overlayContenu.add(w);
        }

        @Override
        public void viderOverlay() {
                overlay.clear();
        }

        @Override
        public void viderOverlayContenu() {
                overlayContenu.clear();
        }
        
        private void gererDimensionsEtPositionnerBoutons() {
                UIObject overlayContenuUi = overlayContenu.getWidget();
                                
                if (overlayContenuUi == null) {
                        return;
                }
                
                int topBoutonFermer = 65;
                int topBoutonsSuivantsPrecedent = (topBoutonFermer + overlayContenuUi.getOffsetHeight())/2 + 20;
                
                
                int left = overlayContenuUi.getAbsoluteLeft() - 20;
                int right = overlayContenuUi.getAbsoluteLeft() + overlayContenuUi.getOffsetWidth() - 12;
                
                DOM.setStyleAttribute(boutonPrecedent.getElement(), "left",left+"px");
                DOM.setStyleAttribute(boutonPrecedent.getElement(), "top", topBoutonsSuivantsPrecedent+"px");
                
                DOM.setStyleAttribute(boutonSuivant.getElement(), "left",right+"px");
                DOM.setStyleAttribute(boutonSuivant.getElement(), "top", topBoutonsSuivantsPrecedent+"px");
                
                DOM.setStyleAttribute(boutonFermer.getElement(), "left",(right - 10)+"px");
                DOM.setStyleAttribute(boutonFermer.getElement(), "top", topBoutonFermer+"px");  
                
                setDimensionsContenu(overlayContenuUi.getOffsetHeight(), overlayContenuUi.getOffsetWidth());
        }
        
        private void setDimensionsContenu(int hauteur, int largeur) {
                largeurContenu = largeur;
                hauteurContenu = hauteur;
        }

        @Override
        public void surOuvertureFenetre() {
                // enregistrement des coordonnées des scrool
                topFenetre = Window.getScrollTop();
                gaucheFenetre = Window.getScrollLeft();
                
                // scroll désactivé pour ne pas fausser le positionnement des boutons
                Window.enableScrolling(false);
                // Pas trouvé mieux que le timer pour bien redimensionner
                // à voir s il existe une meilleure solution qui n'oblige pas 
                // par avance à connaitre le type d'objet contenu dans l'overlayContenu
                // ou bien la taille de la fenetre
                timerPlacement = new Timer() {
                        @Override
                        public void run() {
                                if(tailleDuContenuEstModifiee()) {
                                        // On repositionne les boutons
                                        gererDimensionsEtPositionnerBoutons();
                                }
                        }
                };
                timerPlacement.scheduleRepeating(30);
        }
        
        private boolean tailleDuContenuEstModifiee() {
                UIObject overlayContenuUi = overlayContenu.getWidget();
                return overlayContenuUi != null 
                                && (overlayContenuUi.getOffsetHeight() != hauteurContenu 
                                || overlayContenuUi.getOffsetWidth() != largeurContenu);
        }

        @Override
        public void surFermetureFenetre() {
                Window.enableScrolling(true);
                // replacement de la fenêtre à la position de scroll d'origine
                Window.scrollTo(gaucheFenetre, topFenetre);
                timerPlacement.cancel();
        }
        
        @Override
        public void surSetContenuFenetre() {
                // nécessaire pour le défilement avec les touches du clavier
                overlayContenu.setFocus(true);
        }

        @Override
        public void afficherBoutonsSuivantsPrecedents(boolean afficher) {
                boutonPrecedent.setVisible(afficher);
                boutonSuivant.setVisible(afficher);
        }

        @Override
        public boolean testerFermetureClicExterieur(ClickEvent event) {
                Element e = DOM.eventGetTarget(Event.as(event.getNativeEvent()));
                return event.getRelativeElement() != null && (e == overlayContenu.getElement());
        }
}