Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 475 → Rev 476

/trunk/src/org/tela_botanica/del/client/composants/fenetereoverlay/FenetreOverlayDefilanteVue.ui.xml
New file
0,0 → 1,16
<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui' ui:generateFormat='com.google.gwt.i18n.rebind.format.PropertiesFormat'
ui:generateKeys="com.google.gwt.i18n.rebind.keygen.MD5KeyGenerator"
ui:generateLocales="default">
 
<ui:with field="constants" type="org.tela_botanica.del.client.i18n.Vocabulary" />
<g:VerticalPanel styleName="fenetreDefilante" ui:field="conteneurGlobal">
<g:HTMLPanel ui:field="overlay" />
<g:HorizontalPanel ui:field="conteneurOverlayContenu" styleName="">
<g:Button ui:field="boutonPrecedent" text="" />
<g:FocusPanel ui:field="overlayContenu" />
<g:Button ui:field="boutonSuivant" text="" />
<g:Button ui:field="boutonFermer" text="{constants.fermer}" />
</g:HorizontalPanel>
</g:VerticalPanel>
</ui:UiBinder>
/trunk/src/org/tela_botanica/del/client/composants/fenetereoverlay/FenetreOverlayDefilantePresenteur.java
New file
0,0 → 1,142
package org.tela_botanica.del.client.composants.fenetereoverlay;
 
import org.tela_botanica.del.client.composants.presenteur.Presenteur;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.FocusHandler;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.event.dom.client.HasFocusHandlers;
import com.google.gwt.event.dom.client.HasKeyDownHandlers;
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.shared.HasHandlers;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HasVisibility;
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.IsWidget;
import com.google.gwt.user.client.ui.RootPanel;
 
public abstract class FenetreOverlayDefilantePresenteur {
 
public interface Vue extends IsWidget {
public HasKeyDownHandlers getConteneurGlobal();
public IsWidget getOverlay();
public HasVisibility getOverlayVisibility();
public IsWidget getOverlayContenu();
public HasVisibility getOverlayContenuVisibility();
public HasWidgets getOverlayContenuHasWidgets();
public HasClickHandlers getBoutonFermer();
public HasClickHandlers getBoutonSuivant();
public HasClickHandlers getBoutonPrecedent();
public void setStyleOverlay(String style);
public void setStyleOverlayContenu(String style);
public void setOverlayContenu(IsWidget w);
public void viderOverlay();
public void viderOverlayContenu();
public void surOuvertureFenetre();
public void surFermetureFenetre();
public void surSetContenuFenetre();
public void afficherBoutonsSuivantsPrecedents(boolean afficher);
}
private Vue vue;
private boolean fenetreModaleOuverte = false;
private int indexElementAffiche = 0;
 
// Constructeur
public FenetreOverlayDefilantePresenteur(int indexElementAffiche, Vue vue) {
this.indexElementAffiche = indexElementAffiche;
this.vue = vue;
gererEvenements();
}
// Afficheur
public void go() {
go(null);
}
 
public void go(HasWidgets composite) {
}
 
// Gestion des évènements
protected void gererEvenements() {
vue.getBoutonFermer().addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
fermerFenetreModale();
}
});
vue.getBoutonPrecedent().addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
surClicBoutonPrecedent();
}
});
vue.getBoutonSuivant().addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
surClicBoutonSuivant();
}
});
vue.getConteneurGlobal().addKeyDownHandler(new KeyDownHandler() {
@Override
public void onKeyDown(KeyDownEvent event) {
if(event.getNativeKeyCode() == KeyCodes.KEY_LEFT) {
surClicBoutonPrecedent();
}
if(event.getNativeKeyCode() == KeyCodes.KEY_RIGHT) {
surClicBoutonSuivant();
}
}
});
}
 
public void ouvrirFenetreModaleDefilante(int indexElementAffiche, Presenteur presenteurModal) {
vue.setStyleOverlay("overlay");
vue.setStyleOverlayContenu("overlayContenu");
vue.getOverlayContenuVisibility().setVisible(true);
vue.getOverlayVisibility().setVisible(true);
RootPanel.get().add(vue.asWidget());
fenetreModaleOuverte = true;
setContenuFenetreModale(indexElementAffiche, presenteurModal);
vue.surOuvertureFenetre();
}
public void setContenuFenetreModale(int indexElementAffiche, Presenteur presenteurModal) {
this.indexElementAffiche = indexElementAffiche;
vue.viderOverlayContenu();
presenteurModal.go(vue.getOverlayContenuHasWidgets());
vue.surSetContenuFenetre();
}
public abstract void surClicBoutonSuivant();
public abstract void surClicBoutonPrecedent();
public boolean fenetreModaleEstOuverte() {
return fenetreModaleOuverte;
}
 
public void fermerFenetreModale() {
vue.viderOverlay();
vue.viderOverlayContenu();
RootPanel.get().remove(vue.asWidget());
fenetreModaleOuverte = false;
vue.surFermetureFenetre();
}
public int getIndexElementAffiche() {
return indexElementAffiche;
}
 
public void afficherBoutonsSuivantsPrecedents(boolean afficher) {
vue.afficherBoutonsSuivantsPrecedents(afficher);
}
}
/trunk/src/org/tela_botanica/del/client/composants/fenetereoverlay/FenetreOverlayDefilanteVue.java
New file
0,0 → 1,207
package org.tela_botanica.del.client.composants.fenetereoverlay;
 
import org.tela_botanica.del.client.composants.fenetereoverlay.FenetreOverlayDefilantePresenteur.Vue;
 
import com.google.gwt.core.client.GWT;
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.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.HTMLPanel;
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
HTMLPanel overlay;
@UiField
FocusPanel overlayContenu;
 
@UiField
Button boutonFermer, boutonSuivant, boutonPrecedent;
@UiField
HorizontalPanel conteneurOverlayContenu;
private int hauteurContenu = 0;
private int largeurContenu = 0;
private Timer timerPlacement = null;
public HTMLPanel getOverlay() {
return overlay;
}
 
public FocusPanel getOverlayContenu() {
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 topBoutonsSuivantsPrecedent = (overlayContenuUi.getAbsoluteTop() + overlayContenuUi.getOffsetHeight())/2 + 20;
int topBoutonFermer = overlayContenuUi.getAbsoluteTop() - 10;
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() {
// 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);
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);
}
}