2010-02-22 6 views
2

В настоящее время я работаю над проектом GWT, в котором мне нужно использовать виджет «карусель». Виджет карусели должен отображать фрагменты информации и 2 стрелки - когда пользователь нажимает на одну из стрелок, содержимое перемещается с анимацией и заменяется новым контентом.GWT carousel widget

Я просматриваю доступные виджетные библиотеки, но виджет «карусель», похоже, не доступен. Единственный реальный кандидат, которого я нашел, это виджет gwt-yui-carousel (см. Ссылку ниже), но это, похоже, перегрузка ressources - хотя это почти то, что мне нужно, но вместо отображения простых изображений у меня будет для отображения в условиях MVP представления/презентатора.

Вот виджет работает: http://gwt-yui-carousel.googlecode.com/svn/trunk/www/com.gwtyuicarousel.javascriptload.JavaScriptLoad/javascriptload.html

(идет отсюда: http://code.google.com/p/gwt-yui-carousel/).

Есть ли лучший виджет карусели, о котором я бы не знал? Или я должен расширить существующий, чтобы создать желаемый эффект? Вы бы рекомендовали использовать gwt-yui-carousel (я так не думаю)? Если нет лучшего варианта, считаете ли вы, что было бы неплохо создать виджет самостоятельно?

Обратите внимание, что я считаю, что ключевым моментом здесь является то, что мне нужно будет отобразить презентацию/представления, которые будут извлекать данные в DataBase при нажатии стрелок и т. Д. - поэтому потребуется настройка существующего виджета , или выбранный виджет должен иметь возможность отображать список виджетов GWT.

Опять же, я не думаю, что я могу использовать один из существующих обычных виджетов карусельных, так как те не «GWT-ориентированный» и не мог поддерживать вид/докладчиков и все это GWT материал;)

Любого ответ был бы весьма признателен :)

С наилучшими пожеланиями,

Nils

ответ

1

не знаю, какой-либо доступной реализации, но вы можете написать этот виджет в кратчайшие сроки.

Создать виджет держит список URL-адресов (ваши изображения):

CarouselWidget(ArrayList<String> urls) extends HorizontalPanel 

затем добавить к панели две кнопки и нужные изображения, чтобы показать.

Левая кнопка Кнопки/изображение/изображение/изображение .../изображения/Right

Изображение покормить из списка URL-адресов, а когда левая или правая кнопка нажата вы двигаетесь начальным index - или ++ ... и обновить представление изображения.

С начального индекса вы вычисляете «реальный» индекс в своем массиве.

1

Другое решение для домашнего приготовления может быть основано на GWT LayoutPanel. Это позволит показать анимацию прокрутки, поскольку LayoutPanel реализует интерфейс AnimatedLayout.

public class CarouselPanel extends LayoutPanel { 

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

addToCarousel (Widget виджет) добавит виджет в список виджетов, но не на панели. Фактические виджеты на панели - это те, которые должны отображаться.

Вы можете контролировать расположение отображаемого центра виджету:

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"); 
    }  
} 

и правый виджет на:

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()); 
    } 
} 

Вы также можете использовать правую (или левую) виджет как прокруткой кнопки добавив к ним прослушиватель кликов.

и метод прокрутки может выглядеть следующим образом:

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); 
} 

Примечание метод одушевленные в конце, чтобы переместить виджеты гладким образом.

Не забудьте определить правила CSS для управления Z-индекс центрального виджета:

.sideCarousel { 
    z-index: 0; 
} 

.centerCarousel { 
    z-index: 1; 
} 

Я надеюсь, что это помогает.

0

Это реализация карусели, она использует gwt-query и gwt-queryui. Его можно использовать как по горизонтали, так и по вертикали. Цель использования gwt-запроса - включить анимацию в качестве карусельных движений. Кроме того, он поддерживает спиральное поведение. Я не добавил java-docs в код, но пока вы читаете, вы найдете пояснительные комментарии.

Надеюсь, это было бы полезно.

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)); 
    } 
} 

} 

Пример использования

// 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);