Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 445 → Rev 446

/trunk/src/org/tela_botanica/del/client/navigation/evenement/pagination/EvenementChangementPage.java
7,10 → 7,16
public static com.google.gwt.event.shared.GwtEvent.Type<GestionnaireEvenementChangementPage> TYPE = new com.google.gwt.event.shared.GwtEvent.Type<GestionnaireEvenementChangementPage>();
 
private int pageAAfficher;
private String groupePagination = null;
 
public EvenementChangementPage(int pageAAfficher) {
this.pageAAfficher = pageAAfficher;
}
public EvenementChangementPage(int pageAAfficher, String groupePagination) {
this.pageAAfficher = pageAAfficher;
this.groupePagination = groupePagination;
}
 
@Override
protected void dispatch(GestionnaireEvenementChangementPage handler) {
29,4 → 35,12
public void setPageAAfficher(int pageAAfficher) {
this.pageAAfficher = pageAAfficher;
}
public String getGroupePagination() {
return groupePagination;
}
 
public void setGroupePagination(String groupePagination) {
this.groupePagination = groupePagination;
}
}
/trunk/src/org/tela_botanica/del/client/navigation/evenement/pagination/EvenementChangementPas.java
7,10 → 7,16
public static com.google.gwt.event.shared.GwtEvent.Type<GestionnaireEvenementChangementPas> TYPE = new com.google.gwt.event.shared.GwtEvent.Type<GestionnaireEvenementChangementPas>();
 
private int pas;
private String groupePagination = null;
 
public EvenementChangementPas(int pas) {
this.pas = pas;
}
public EvenementChangementPas(int pas, String groupePagination) {
this.pas = pas;
this.groupePagination = groupePagination;
}
 
@Override
protected void dispatch(GestionnaireEvenementChangementPas handler) {
29,5 → 35,13
public void setPas(int pas) {
this.pas = pas;
}
public String getGroupePagination() {
return groupePagination;
}
 
public void setGroupePagination(String groupePagination) {
this.groupePagination = groupePagination;
}
 
}
/trunk/src/org/tela_botanica/del/client/vues/rechercheimages/resultats/ResultatRechercheImagePresenteur.java
109,6 → 109,8
 
PaginationPresenteur imagesPaginationPresenteurHaut = creerPresenteurPagination(nbImages);
PaginationPresenteur imagesPaginationPresenteurBas = creerPresenteurPagination(nbImages);
imagesPaginationPresenteurHaut.setGroupePagination("pagination_images");
imagesPaginationPresenteurBas.setGroupePagination("pagination_images");
imagesPaginationPresenteurHaut.go(vue.getPanneauPaginationHaut());
imagesPaginationPresenteurBas.go(vue.getPanneauPagination());
}
/trunk/src/org/tela_botanica/del/client/vues/rechercheobservations/resultats/ResultatsRechercheObservationsPresenteur.java
76,6 → 76,8
vue.getZonePaginationBas().clear();
PaginationPresenteur paginationPresenteurHaut = creerPresenteurPagination(nbObservations);
PaginationPresenteur paginationPresenteurBas = creerPresenteurPagination(nbObservations);
paginationPresenteurHaut.setGroupePagination("pagination_observations");
paginationPresenteurBas.setGroupePagination("pagination_observations");
paginationPresenteurHaut.go(vue.getZonePaginationHaut());
paginationPresenteurBas.go(vue.getZonePaginationBas());
}
/trunk/src/org/tela_botanica/del/client/composants/pagination/PaginationPresenteur.java
73,6 → 73,8
private int pageCourante = 1;
private int nbElementsTotal = 0;
private int pas = 10;
private String groupePagination = null;
 
/**
* Constructeur de l'application
87,6 → 89,8
this.vue = vue;
this.pas = pas;
this.pageCourante = pageCourante;
this.nbPage = calculerNbPage();
}
 
/**
110,8 → 114,7
vue.getSelecteurPas().addChangeHandler(new ChangeHandler() {
@Override
public void onChange(ChangeEvent event) {
chargerElements(0, vue.getPasSelectionne());
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPas(vue.getPasSelectionne()));
changerPas(vue.getPasSelectionne());
}
});
 
132,7 → 135,7
vue.getBoutonPremierePage().addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
afficherLaPremierePage();
allerALaPremierePage();
}
});
 
139,7 → 142,7
vue.getBoutonDernierePage().addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
afficherlaDernierePage();
allerAlaDernierePage();
}
});
 
147,8 → 150,10
 
@Override
public void onChangementPage(EvenementChangementPage event) {
pageCourante = event.getPageAAfficher();
mettreEnValeurPageCourante();
if(event.getGroupePagination() == groupePagination) {
pageCourante = event.getPageAAfficher();
mettreEnValeurPageCourante();
}
}
});
 
156,19 → 161,23
 
@Override
public void onChangementPas(EvenementChangementPas event) {
 
// remet la page a zero lors du changement de pas
pageCourante = 1;
 
// modifie le pas et les liens en fonction
pas = event.getPas();
actualiserPas();
actualiserLiensPagesPagination();
 
if(event.getGroupePagination() == groupePagination) {
// modifie le pas et les liens en fonction
pas = event.getPas();
actualiserPas();
actualiserLiensPagesPagination();
}
}
});
}
 
private void gererDecalagePageCourante(int ancienPas, int nouveauPas) {
if(ancienPas != nouveauPas) {
double rapportPas = (double)ancienPas/(double)nouveauPas;
pageCourante = (int)(Math.ceil((double)pageCourante*(double)rapportPas));
}
}
/**
* Gérer les évènements sur les boutons dynamiques (qui sont recréés à
* chaque fois)
182,8 → 191,9
public void onClick(ClickEvent event) {
HasText boutonCourant = (HasText) event.getSource();
int pageAAfficher = Integer.parseInt(boutonCourant.getText());
pageCourante = pageAAfficher;
chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
}
});
}
225,12 → 235,21
public void setPageCourante(int pageCourante) {
this.pageCourante = pageCourante;
}
public void changerPas(int nouveauPas) {
gererDecalagePageCourante(pas, nouveauPas);
pas = nouveauPas;
chargerElements((pageCourante - 1)*pas, pageCourante*pas);
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPas(nouveauPas, groupePagination));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageCourante, groupePagination));
}
 
public void allerALaPagePrecedente() {
if (pageCourante > 1) {
int pageAAfficher = pageCourante - 1;
pageCourante = pageAAfficher;
chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
}
 
}
238,21 → 257,24
public void allerALapageSuivante() {
if (pageCourante < nbPage - 1) {
int pageAAfficher = pageCourante + 1;
pageCourante = pageAAfficher;
chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
}
}
 
public void afficherLaPremierePage() {
public void allerALaPremierePage() {
int pageAAfficher = 1;
pageCourante = pageAAfficher;
chargerElements(0, pas);
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
}
 
public void afficherlaDernierePage() {
public void allerAlaDernierePage() {
int pageAAfficher = nbPage - 1;
pageCourante = pageAAfficher;
chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher));
BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
}
 
/** calcule le nombre de page en fonction du pas */
284,5 → 306,13
public void setPas(int pas) {
this.pas = pas;
}
public void setGroupePagination(String groupePagination) {
this.groupePagination = groupePagination;
}
public String getGroupePagination() {
return groupePagination;
}
 
}
/trunk/src/org/tela_botanica/del/test/composants/pagination/PaginationPresenteurTest.java
1,106 → 1,137
package org.tela_botanica.del.test.composants.pagination;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.*;
import static org.mockito.Mockito.when;
 
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.tela_botanica.del.client.cache.CacheClient;
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur;
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur.Vue;
 
import com.google.gwt.event.dom.client.HasChangeHandlers;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.user.client.ui.HasWidgets;
 
public class PaginationPresenteurTest {
 
/**
* Presenteur utilisé pour le test de synchro pagination
*/
PaginationPresenteur paginationHautPresenteur;
/**
* Presenteur utilisé pour le test de synchro pagination
*/
PaginationPresenteur paginationBasPresenteur;
 
/**
* Presenteur utilisé seul qui ne doit pas réagir au évènements lancés par les deux autres
*/
PaginationPresenteur paginationPresenteurSeul;
 
boolean boutonPremierePageEstAffiche;
boolean boutonDernierePageEstAffiche;
 
@Before
@Before
public void setUp() {
PaginationPresenteur.Vue vueBas = creerMockVuePaginationPresenteurBasique();
PaginationPresenteur.Vue vueBas = creerMockVuePaginationPresenteurBasique();
this.paginationBasPresenteur = new PaginationPresenteur(vueBas, 100, 10, 1) {
 
@Override
public void chargerElements(int debut, int fin) {
// TODO: tester avec des données factices, est-ce utile ici ?
// TODO Auto-generated method stub
}
 
@Override
public void actualiserPasCache(int pas) {
CacheClient.getInstance().setPasPagination(pas);
// TODO Auto-generated method stub
}
 
};
 
PaginationPresenteur.Vue vueHaut = creerMockVuePaginationPresenteurBasique();
this.paginationHautPresenteur = new PaginationPresenteur(vueHaut, 100, 10, 1) {
this.paginationHautPresenteur = new PaginationPresenteur(vueHaut,100, 10, 1) {
 
 
@Override
public void chargerElements(int debut, int fin) {
 
public void actualiserPasCache(int pas) {
}
 
@Override
public void actualiserPasCache(int pas) {
 
public void chargerElements(int debut, int fin) {
// TODO Auto-generated method stub
}
 
};
 
PaginationPresenteur.Vue vueSeule = creerMockVuePaginationPresenteurBasique();
this.paginationPresenteurSeul = new PaginationPresenteur(vueSeule, 100, 10, 1) {
 
@Override
public void chargerElements(int debut, int fin) {
}
public void actualiserPasCache(int pas) {}
 
@Override
public void actualiserPasCache(int pas) {
public void chargerElements(int debut, int fin) {
// TODO Auto-generated method stub
}
 
};
HasWidgets containerMock = Mockito.mock(HasWidgets.class);
paginationHautPresenteur.setGroupePagination("pagination_synchro");
paginationBasPresenteur.setGroupePagination("pagination_synchro");
paginationHautPresenteur.go(containerMock);
paginationBasPresenteur.go(containerMock);
paginationPresenteurSeul.go(containerMock);
}
 
@Test
public void testAffichageBoutonPremiereDernierePage() {
 
mockerMethodeAffichageBoutons(paginationPresenteurSeul.getVue());
 
// TODO: voir comment mocker ces méthodes avec Benjamin car le test ne
// passe alors que
// ça fonctionne en pratique
paginationPresenteurSeul.afficherLaPremierePage();
assertEquals(1, paginationPresenteurSeul.getPageCourante());
/*
* assertEquals(false,
* paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
* assertEquals(true,
* paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());
*/
 
paginationPresenteurSeul.afficherlaDernierePage();
assertEquals(9, paginationPresenteurSeul.getPageCourante());
/*
* assertEquals(false,
* paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
* assertEquals(false,
* paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());
*/
 
public void testSynchronisationChangementPageCourante() {
assertEquals(1, paginationHautPresenteur.getPageCourante());
assertEquals(1, paginationBasPresenteur.getPageCourante());
paginationBasPresenteur.allerALapageSuivante();
assertEquals(2, paginationHautPresenteur.getPageCourante());
}
 
@Test
public void testSynchronisationChangementPasEtDecalage() {
assertEquals(1, paginationHautPresenteur.getPageCourante());
assertEquals(1, paginationBasPresenteur.getPageCourante());
paginationBasPresenteur.allerALapageSuivante();
paginationBasPresenteur.allerALapageSuivante();
paginationBasPresenteur.allerALapageSuivante();
assertEquals(4, paginationHautPresenteur.getPageCourante());
paginationBasPresenteur.changerPas(5);
assertEquals(5, paginationHautPresenteur.getPas());
assertEquals(8, paginationBasPresenteur.getPageCourante());
}
@Test
public void testSynchronisationChangementPas() {
paginationBasPresenteur.changerPas(20);
assertEquals(1, paginationBasPresenteur.getPageCourante());
assertEquals(20, paginationHautPresenteur.getPas());
}
@Test
public void testGroupePaginationDifferents() {
paginationPresenteurSeul.allerALapageSuivante();
assertEquals(2, paginationPresenteurSeul.getPageCourante());
paginationBasPresenteur.allerAlaDernierePage();
assertEquals(9, paginationHautPresenteur.getPageCourante());
assertEquals(9, paginationBasPresenteur.getPageCourante());
assertEquals(2, paginationPresenteurSeul.getPageCourante());
}
private PaginationPresenteur.Vue creerMockVuePaginationPresenteurBasique() {
 
PaginationPresenteur.Vue vueMock = Mockito.mock(PaginationPresenteur.Vue.class);
PaginationPresenteur.Vue vueMock = Mockito.mock(PaginationPresenteur.Vue.class);
HasWidgets zoneLiens = Mockito.mock(HasWidgets.class);
HasChangeHandlers selecteurPas = Mockito.mock(HasChangeHandlers.class);
HasClickHandlers boutonPrecedent = Mockito.mock(HasClickHandlers.class);
107,7 → 138,7
HasClickHandlers boutonSuivant = Mockito.mock(HasClickHandlers.class);
HasClickHandlers boutonPremierePage = Mockito.mock(HasClickHandlers.class);
HasClickHandlers boutonDernierePage = Mockito.mock(HasClickHandlers.class);
 
when(vueMock.getZoneLiens()).thenReturn(zoneLiens);
when(vueMock.getSelecteurPas()).thenReturn(selecteurPas);
when(vueMock.getBoutonPrecedent()).thenReturn(boutonPrecedent);
114,41 → 145,7
when(vueMock.getBoutonSuivant()).thenReturn(boutonSuivant);
when(vueMock.getBoutonPremierePage()).thenReturn(boutonPremierePage);
when(vueMock.getBoutonDernierePage()).thenReturn(boutonDernierePage);
 
return vueMock;
}
 
private void mockerMethodeAffichageBoutons(Vue vueMock) {
 
when(vueMock.boutonPrecedentEstAffiche()).thenReturn(boutonPremierePageEstAffiche);
when(vueMock.boutonSuivantEstAffiche()).thenReturn(boutonDernierePageEstAffiche);
 
Mockito.doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) {
boutonPremierePageEstAffiche = true;
return boutonPremierePageEstAffiche;
}
}).when(vueMock).afficherBoutonPrecedent();
 
Mockito.doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) {
boutonDernierePageEstAffiche = true;
return boutonDernierePageEstAffiche;
}
}).when(vueMock).afficherBoutonSuivant();
 
Mockito.doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) {
boutonPremierePageEstAffiche = false;
return boutonPremierePageEstAffiche;
}
}).when(vueMock).masquerBoutonPrecedent();
 
Mockito.doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) {
boutonDernierePageEstAffiche = false;
return boutonDernierePageEstAffiche;
}
}).when(vueMock).masquerBoutonSuivant();
}
}