2010-02-22 18 views
2

Je travaille actuellement sur un projet GWT, dans lequel j'ai besoin d'utiliser un widget "carrousel". Le widget carrousel est censé afficher des informations et 2 flèches - lorsque l'utilisateur clique sur l'une des flèches, le contenu est déplacé avec une animation et remplacé par un nouveau contenu.GWT carrousel widget

que je cherchais à travers les libs widget disponibles, mais le widget « carrousel » ne semble pas être que disponible. Le seul vrai candidat que j'ai trouvé est le widget gwt-yui-carrousel (voir lien ci-dessous), mais cela semble être une surcharge de ressources - bien qu'il fasse presque exactement ce dont j'ai besoin, mais au lieu d'afficher des images simples, pour afficher, en termes MVP, une vue/présentateur.

Voici le widget fonctionnement: http://gwt-yui-carousel.googlecode.com/svn/trunk/www/com.gwtyuicarousel.javascriptload.JavaScriptLoad/javascriptload.html

(à venir d'ici: http://code.google.com/p/gwt-yui-carousel/).

Y at-il un meilleur widget carrousel disponible que je ne sais pas de? Ou devrais-je prolonger un existant pour créer l'effet désiré? Recommanderiez-vous d'utiliser le gwt-yui-carrousel (je ne pense pas)? S'il n'y a pas de meilleure option, pensez-vous que ce serait une bonne idée de créer le widget moi-même? Notez que je pense que le point clé est, ici, que je vais devoir afficher le présentateur/vues, qui ira chercher des données dans DataBase sur des clics de souris et ainsi de suite - donc une personnalisation d'un widget existant serait nécessaire ou le widget choisi devrait être capable d'afficher une liste de Widgets GWT.

Encore une fois, je ne pense pas que je peux utiliser l'un des widgets carrousel habituels existants, puisque ce ne sont pas « GWT-oriented » et ne pouvait pas soutenir vue/présentateurs et tout ce genre de choses GWT;)

Tous réponse serait grandement appréciée :)

Meilleures salutations,

Nils

Répondre

1

ne sait pas d'une mise en œuvre disponible mais vous pouvez écrire ce widget en peu de temps.

Créer un widget maintenant une liste d'URL (vos images):

CarouselWidget(ArrayList<String> urls) extends HorizontalPanel 

puis ajouter au panneau deux boutons et les images désirées pour montrer.

bouton gauche/image/image/image .../image/bouton droit

Les images sont flux de votre liste d'URL et lorsque le bouton gauche ou à droite est cliqué vous déplacer le départ index - ou ++ ... et rafraîchit la vue de l'image.

A partir de l'index de départ calculer l'indice « réel » dans votre tableau.

1

Une autre solution brassée à domicile peut être basé sur GWT LayoutPanel. Cela permettra d'afficher l'animation du défilement lorsque LayoutPanel implémente l'interface AnimatedLayout.

public class CarouselPanel extends LayoutPanel { 

    int itsCurrentWidget = 0; 
    private ArrayList<Widget> itsWidgets; 
    private Button itsLeftButton; 
    private Button itsRightButton; 

addToCarousel (widget Widget) va ajouter le widget à la liste des widgets, mais pas au panneau. Les widgets réels dans le panneau sont ceux qui devraient être affichés.

Vous pouvez contrôler la mise en page du widget centre affiché par:

private void setCenter(Widget widget, boolean newWidget) { 
    if (widget != null) { 
     if (newWidget) 
      add(widget); 
     setWidgetLeftWidth(widget, 10, Unit.PCT, 80, Unit.PCT); 
     setWidgetTopHeight(widget, 10, Unit.PCT, 80, Unit.PCT); 
     widget.removeStyleName("sideCarousel"); 
     widget.setStylePrimaryName("centerCarousel"); 
    }  
} 

et le widget droit par:

private void setRight(Widget widget, boolean newWidget) { 
    if (widget != null) { 
     if (newWidget) 
      add(widget); 
     setWidgetLeftWidth(widget, 50, Unit.PCT, 45, Unit.PCT); 
     setWidgetTopHeight(widget, 20, Unit.PCT, 60, Unit.PCT); 
     widget.removeStyleName("centerCarousel"); 
     widget.setStylePrimaryName("sideCarousel"); 
     if (itsRightHandler != null) 
      itsRightHandler.removeHandler(); 
     itsRightHandler = widget.addDomHandler(new ClickHandler() { 
      public void onClick(final ClickEvent event) { 
       scrollRight(); 
      } 
     }, ClickEvent.getType()); 
    } 
} 

Vous pouvez également utiliser le droit (ou gauche) widget comme des boutons de défilement en leur ajoutant un écouteur de clic.

et la méthode de défilement peut ressembler à ceci:

public void scrollRight() { 
    if (itsCurrentWidget >= getWidgetCountInCarousel()-1) 
     return; 
    if (itsCurrentWidget > 0) { 
     Widget hideWidget = getWidgetInCarousel(itsCurrentWidget-1); 
     remove(hideWidget); 
    } 
    Widget leftWidget = getWidgetInCarousel(itsCurrentWidget); 
    Widget centerWidget = getWidgetInCarousel(++itsCurrentWidget); 
    Widget rightWidget = null; 
    if (itsCurrentWidget+1 < getWidgetCountInCarousel()) { 
     rightWidget = getWidgetInCarousel(itsCurrentWidget+1); 
    } 
    setLeft(leftWidget, false); 
    setRight(rightWidget, true); 
    setCenter(centerWidget, false); 
    animate(500); 
} 

Notez la méthode Animer à la fin pour déplacer les widgets de manière lisse.

Ne pas oublier de définir les règles CSS pour contrôler le z-index du widget centre:

.sideCarousel { 
    z-index: 0; 
} 

.centerCarousel { 
    z-index: 1; 
} 

J'espère que ça aide.

0

Ceci est une implémentation de carrousel, il utilise gwt-query et gwt-queryui. Il peut être utilisé horizontalement ou verticalement. Le but de l'utilisation de gwt-query est de permettre des animations comme des mouvements de carrousel. De plus, il favorise le comportement en spirale. Je n'ai pas ajouté java-docs au code, mais tant que vous lisez, vous trouverez des commentaires explicatifs.

Espérons que ce serait utile.

import com.google.gwt.event.dom.client.ClickEvent; 
import com.google.gwt.event.dom.client.ClickHandler; 
import com.google.gwt.user.client.ui.AbsolutePanel; 
import com.google.gwt.user.client.ui.Button; 
import com.google.gwt.user.client.ui.Composite; 
import com.google.gwt.user.client.ui.FlexTable; 
import com.google.gwt.user.client.ui.HasHorizontalAlignment; 
import com.google.gwt.user.client.ui.HasVerticalAlignment; 
import com.google.gwt.user.client.ui.Widget; 
import com.google.gwt.query.client.Function; 
import java.util.ArrayList; 
import java.util.List; 
import static com.google.gwt.query.client.GQuery.$; 

/** 
GWTCrousel implementation. 
    @author: Andrés82 
*/ 
public class GWTCarousel extends Composite { 

    /* 
     Public constants 
    */ 
public static final int HORIZONTAL = 0; // used for orientation 
public static final int VERTICAL = 1; 

/* 
     Constructor 
    */ 
public GWTCarousel() { 

      // inits the widget 
    mainPanel = new FlexTable(); 
    initWidget(mainPanel); 

      // structure 
    viewport = new AbsolutePanel(); 
    widgetsTable = new FlexTable(); 
    viewport.add(widgetsTable); 
    viewport.setWidgetPosition(widgetsTable,0,0); 

    // default behavior (not spiral, not animations enabled) 
    spiral = false; animationEnabled = false; 
    nextRow = 0; nextCol = 0; numberOfWidgetsToShow = 0; 
    movement = 0; animationTime = DEFAULT_ANIMATION_TIME; 
    widgetsList = new ArrayList<Widget>(); 

    // basics styling 
      $(viewport).css("overflow","hidden"); 
    widgetsTable.setCellSpacing(SPACING); 
    mainPanel.setCellSpacing(SPACING); 
} 

    // sets the carousel orientation 
public void setOrientation (int orientation) { 
    switch (orientation) { 
     case HORIZONTAL: 
      setHorizontalOrientation(); 
      break; 
     case VERTICAL: 
      setVerticalOrientation(); 
      break; 
     default:; 
    } 
    previous.addClickHandler(getpreviousClickHandler()); 
    next.addClickHandler(getnextClickHandler()); 

} 

    /* 
     Getters and setters 
    */ 

public int getOrientation() { return orientation; } 

public void setSpiral(boolean spiral) { this.spiral = spiral; } 

public boolean isSpiral() { return spiral; } 

public T2VoiceButton getprevious() { return previous; } 

public T2VoiceButton getnext() { return next; } 

public int getNumberOfWidgetsToShow() { return numberOfWidgetsToShow; } 

    // sets the number of widgets to show in the viewport 
public void setNumberOfWidgetsToShow(int numberOfWidgetsToShow) { this.numberOfWidgetsToShow = numberOfWidgetsToShow; } 

public void setAnimationEnabled(boolean animationEnabled) { this.animationEnabled = animationEnabled; } 

public boolean isAnimationEnabled() { return animationEnabled; } 

public double getWidgetWidth() { return widgetWidth; } 

public void setWidgetWidth(double widgetWidth) { 
    this.widgetWidth = widgetWidth; 
    double viewportWidth = orientation == HORIZONTAL ? widgetWidth * numberOfWidgetsToShow + (numberOfWidgetsToShow + 1) * SPACING : widgetWidth + 2 * SPACING; 
    viewport.setWidth(viewportWidth + "px"); 
} 

public double getWidgetHeight() { return widgetHeight; } 

public void setWidgetHeight(double widgetHeight) { 
    this.widgetHeight = widgetHeight; 
    double viewportHeight = orientation == VERTICAL ? widgetHeight * numberOfWidgetsToShow + (numberOfWidgetsToShow + 1) * SPACING : widgetHeight + 2 * SPACING; 
    viewport.setHeight(viewportHeight + "px"); 
} 

public void setanimationTime(int animationTime) { this.animationTime = animationTime; } 

public int getanimationTime() { return animationTime; } 

    /* 
     Other methods 
    */ 

public void addWidget (Widget widgetToAdd) { 
    switch (orientation) { 
     case HORIZONTAL: 
      addWidgetHorizontally(widgetToAdd); 
      break; 
     case VERTICAL: 
      addWidgetVertically(widgetToAdd); 
      break; 
     default:; 
    } 

} 

    /* 
     Fields and constants 
    */ 

    // constants 
private final int SPACING = 5; 
private final int DEFAULT_ANIMATION_TIME = 300; // defined in millis 

// structure 
private Button previous; 
private Button next; 
private AbsolutePanel viewport; 
private FlexTable widgetsTable; 
private FlexTable mainPanel; 

// control variables 
private boolean spiral; 
private boolean animationEnabled; 
private long animationTime; // defined in millis 
private double widgetWidth; 
private double widgetHeight; 
private int orientation; 
private int numberOfWidgetsToShow; 
private int nextRow; 
private int nextCol; 
private int movement; 
private List<Widget> widgetsList; 

    /* 
     Private methods 
    */ 

private void addWidgetVertically(Widget widgetToAdd) { 
    nextRow++; 
    widgetsList.add(widgetToAdd); 
    widgetsTable.setWidget(nextRow, nextCol, widgetToAdd); 
    widgetsTable.getCellFormatter().setAlignment(nextRow, nextCol, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    if (spiral && nextRow > numberOfWidgetsToShow) { 
     shiftDown(); 
     $(widgetsTable).css("top", -(widgetHeight + SPACING) + "px"); 
    } 
} 

private void addWidgetHorizontally(Widget widgetToAdd) { 
    nextCol++; 
    widgetsList.add(widgetToAdd); 
    widgetsTable.setWidget(nextRow, nextCol, widgetToAdd); 
    widgetsTable.getCellFormatter().setAlignment(nextRow, nextCol, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    if (spiral && nextCol > numberOfWidgetsToShow) { 
     shiftRight(); 
     $(widgetsTable).css("left", -(widgetWidth + SPACING) + "px"); 
    } 
} 

private void setHorizontalOrientation() { 
    orientation = HORIZONTAL; 
    // botones 
    previous = new T2VoiceButton (null,null,null); 
    next = new T2VoiceButton (null,null,null); 
    mainPanel.setWidget(0, 0, previous); 
    mainPanel.setWidget(0, 1, viewport); 
    mainPanel.setWidget(0, 2, next); 
    mainPanel.getFlexCellFormatter().setAlignment(0, 0, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    mainPanel.getFlexCellFormatter().setAlignment(0, 1, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    mainPanel.getFlexCellFormatter().setAlignment(0, 2, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
} 

private void setVerticalOrientation() { 
    orientation = VERTICAL; 
    // botones 
    previous = new T2VoiceButton (null,null,null); 
    next = new T2VoiceButton (null,null,null); 
    mainPanel.setWidget(0, 0, previous); 
    mainPanel.setWidget(1, 0, viewport); 
    mainPanel.setWidget(2, 0, next); 
    mainPanel.getFlexCellFormatter().setAlignment(0, 0, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    mainPanel.getFlexCellFormatter().setAlignment(1, 0, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
    mainPanel.getFlexCellFormatter().setAlignment(2, 0, HasHorizontalAlignment.ALIGN_CENTER, HasVerticalAlignment.ALIGN_MIDDLE); 
} 

private ClickHandler getpreviousClickHandler() { 
    switch (orientation) { 
     case HORIZONTAL: 
      return new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent event) { 
        moveLeft(); 
       } 
      }; 
     case VERTICAL: 
      return new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent event) { 
        moveUp(); 
       } 
      }; 
     default: 
      return null; 
    } 
} 

private ClickHandler getnextClickHandler() { 
    switch (orientation) { 
     case HORIZONTAL: 
      return new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent event) { 
        moveRight(); 
       } 
      }; 
     case VERTICAL: 
      return new ClickHandler() { 
       @Override 
       public void onClick(ClickEvent event) { 
        moveDown(); 
       } 
      }; 
     default: 
      return null; 
    } 
} 

private void moveLeft() { 
    if (!spiral && movement > (numberOfWidgetsToShow - nextCol - 1)) { 
     movement--; 
     $(widgetsTable).animate("left: -=" + (widgetWidth + SPACING), animationEnabled ? animationTime : 0); 
    } else if (spiral) {  
     $(widgetsTable).animate("left: -=" + (widgetWidth + SPACING), animationEnabled ? animationTime : 0, new Function() { 
      @Override 
      public void f() { 
       shiftLeft(); 
       $(widgetsTable).css("left", -(widgetWidth + SPACING + 1) + "px"); 
      } 
     }); 
    } 
} 

private void shiftLeft() { 
    Widget widgetToMove = widgetsList.get(0); 
    widgetsList.remove(0); 
    widgetsList.add(widgetToMove); 
    for (int column = 0; column < nextCol; column++) { 
     widgetsTable.setWidget(0, column, widgetsList.get(column)); 
    } 
} 

private void moveRight() { 
    if (!spiral && movement < 1) { 
     movement++; 
     $(widgetsTable).animate("left: +=" + (widgetWidth + SPACING), animationEnabled ? animationTime : 0); 
    } else if (spiral) { 
     $(widgetsTable).animate("left: +=" + (widgetWidth + SPACING), animationEnabled ? animationTime : 0, new Function() { 
      @Override 
      public void f() { 
       shiftRight(); 
       $(widgetsTable).css("left", -(widgetWidth + SPACING + 1) + "px"); 
      } 
     }); 
    } 
} 

private void shiftRight() { 
    Widget widgetToMove = widgetsList.get(nextCol - 1); 
    widgetsList.remove(nextCol - 1); 
    widgetsList.add(0, widgetToMove); 
    for (int column = 0; column < nextCol; column++) { 
     widgetsTable.setWidget(0, column, widgetsList.get(column)); 
    } 
} 

private void moveUp() { 
    if (!spiral && movement < (nextRow - numberOfWidgetsToShow)) { 
     movement++; 
     $(widgetsTable).animate("top: -=" + (widgetHeight + SPACING), animationEnabled ? animationTime : 0); 
    } else if (spiral) { 
     $(widgetsTable).animate("top: -=" + (widgetHeight + SPACING), animationEnabled ? animationTime : 0, new Function() { 
      @Override 
      public void f() { 
       shiftUp(); 
       $(widgetsTable).css("top", -(widgetHeight + SPACING + 1) + "px"); 
      } 
     }); 
    } 
} 

private void shiftUp() { 
    Widget widgetToMove = widgetsList.get(0); 
    widgetsList.remove(0); 
    widgetsList.add(widgetToMove); 
    for (int row = 0; row < nextRow; row++) { 
     widgetsTable.setWidget(row, 0, widgetsList.get(row)); 
    } 
} 

private void moveDown() { 
    if (!spiral && movement > 0) { 
     movement--; 
     $(widgetsTable).animate("top: +=" + (widgetHeight + SPACING), animationEnabled ? animationTime : 0); 
    } else if (spiral) { 
     $(widgetsTable).animate("top: +=" + (widgetHeight + SPACING), animationEnabled ? animationTime : 0, new Function() { 
      @Override 
      public void f() { 
       shiftDown(); 
       $(widgetsTable).css("top", -(widgetHeight + SPACING + 1) + "px"); 
      } 
     }); 
    } 
} 

private void shiftDown() { 
    Widget widgetToMove = widgetsList.get(nextRow - 1); 
    widgetsList.remove(nextRow - 1); 
    widgetsList.add(0, widgetToMove); 
    for (int row = 0; row < nextRow; row++) { 
     widgetsTable.setWidget(row, 0, widgetsList.get(row)); 
    } 
} 

} 

Exemple d'utilisation

// shows 5 widgets in the viewport 
GWTCarousel horizontalSpiralCarousel = new GWTCarousel(); 
horizontalSpiralCarousel.setAnimationEnabled(true); 
horizontalSpiralCarousel.setSpiral(true); 
horizontalSpiralCarousel.setMillisToMove(200); 
horizontalSpiralCarousel.setOrientation(T2VoiceCarousel.HORIZONTAL); 
horizontalSpiralCarousel.setNumberOfWidgetsToShow(5); 
horizontalSpiralCarousel.setWidgetWidth(100.0); 
horizontalSpiralCarousel.setWidgetHeight(100.0); 

// adding widgets to carousel 
HorizontalPanel maroonTile = new HorizontalPanel(); 
$(maroonTile).css("background-color","maroon"); 
$(maroonTile).css("width", 100.0 + "px"); 
$(maroonTile).css("height", 100.0 + "px"); 
HorizontalPanel greenTile = new HorizontalPanel(); 
$(greenTile).css("background-color","green"); 
$(greenTile).css("width", 100.0 + "px"); 
$(greenTile).css("height", 100.0 + "px"); 
HorizontalPanel redTile = new HorizontalPanel(); 
$(redTile).css("background-color","red"); 
$(redTile).css("width", 100 + "px"); 
$(redTile).css("height", 100 + "px"); 
HorizontalPanel yellowTile = new HorizontalPanel(); 
$(yellowTile).css("background-color","yellow"); 
$(yellowTile).css("width", 100.0 + "px"); 
$(yellowTile).css("height", 100.0 + "px"); 
HorizontalPanel blueTile = new HorizontalPanel(); 
$(blueTile).css("background-color","blue"); 
$(blueTile).css("width", 100.0 + "px"); 
$(blueTile).css("height", 100.0 + "px"); 

horizontalCarousel.addWidget(maroonTile); 
horizontalCarousel.addWidget(greenTile); 
horizontalCarousel.addWidget(redTile); 
horizontalCarousel.addWidget(blueTile); 
horizontalCarousel.addWidget(yellowTile);