【问题标题】:GWT carousel widgetGWT 轮播小部件
【发布时间】:2011-01-19 13:39:17
【问题描述】:

我目前正在处理一个 GWT 项目,我需要在其中使用“轮播”小部件。 carousel 小部件应该显示信息片段和 2 个箭头 - 当用户单击其中一个箭头时,内容将通过动画移动并替换为新内容。

我一直在查看可用的小部件库,但“轮播”小部件似乎不可用。我发现的唯一真正的候选者是 gwt-yui-carousel 小部件(见下面的链接),但这似乎是资源的超载 - 虽然它几乎完全符合我的需要,但我不会显示简单的图像,而是以 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(我不这么认为)吗? 如果没有更好的选择,您认为自己创建小部件是个好主意吗?

请注意,我认为关键是,在这里,我必须显示演示者/视图,这将在单击箭头等时在数据库中获取数据 - 因此需要对现有小部件进行自定义,或者选择的小部件应该能够显示 GWT 小部件列表。

我不认为我可以使用现有的常用轮播小部件之一,因为它们不是“面向 gwt”的,并且无法支持视图/演示者和所有这些 gwt 东西;)

任何答案将不胜感激:)

最好的问候,

尼尔斯

【问题讨论】:

    标签: gwt widget carousel


    【解决方案1】:

    不知道任何可用的实现,但您可以立即编写此小部件。

    创建一个包含 URL 列表(您的图像)的小部件:

    CarouselWidget(ArrayList<String> urls) extends HorizontalPanel
    

    然后在面板中添加两个按钮和要显示的图像。

    左键 / image / image / image ... / image / 右键

    图片来自您的 url 列表,当点击左或右按钮时 您移动起始索引 - 或 ++ ...并刷新图像视图。

    从起始索引计算数组中的“真实”索引。

    【讨论】:

      【解决方案2】:

      另一个自制的解决方案可以基于 GWT LayoutPanel。这将允许显示滚动的动画,因为 LayoutPanel 实现了 AnimatedLayout 接口。

         public class CarouselPanel extends LayoutPanel {
      
          int itsCurrentWidget = 0;
          private ArrayList<Widget> itsWidgets;
          private Button itsLeftButton;
          private Button itsRightButton;
      

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

      注意最后的 animate 方法以平滑移动小部件。

      不要忘记定义 CSS 规则来控制中心小部件的 z-index:

       .sideCarousel {
          z-index: 0;
      }
      
      .centerCarousel {
          z-index: 1;
      }
      

      希望对你有帮助。

      【讨论】:

        【解决方案3】:

        这是一个轮播实现,它使用gwt-query 和gwt-queryui。它可以水平使用,也可以垂直使用。使用 gwt-query 的目的是在轮播移动时启用动画。此外,它支持螺旋行为。我没有在代码中添加 java-docs,但只要你阅读,你会发现解释性的 cmets。

        希望这会很有用。

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

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 2020-03-02
          • 2012-03-15
          • 2011-09-10
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          相关资源
          最近更新 更多