Add generic resize performance testbed and a test UI for Grid

Change-Id: I61a2bb0836cf4f2bbbb9c5de3f9f5dc11cbe7c81

4 files changed, 384 insertions, 0 deletions

diff --git a/uitest/src/com/vaadin/tests/components/grid/GridResizeTerror.java b/uitest/src/com/vaadin/tests/components/grid/GridResizeTerror.java
new file mode 100644
index 0000000000..3fa861b32e
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/components/grid/GridResizeTerror.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.tests.components.grid;
+
+import com.vaadin.annotations.Widgetset;
+import com.vaadin.server.VaadinRequest;
+import com.vaadin.tests.util.ResizeTerrorizer;
+import com.vaadin.tests.widgetset.TestingWidgetSet;
+import com.vaadin.ui.Grid;
+import com.vaadin.ui.UI;
+
+@Widgetset(TestingWidgetSet.NAME)
+public class GridResizeTerror extends UI {
+    @Override
+    protected void init(VaadinRequest request) {
+        Grid grid = new Grid();
+
+        int cols = 10;
+        Object[] data = new Object[cols];
+
+        for (int i = 0; i < cols; i++) {
+            grid.addColumn("Col " + i);
+            data[i] = "Data " + i;
+        }
+
+        for (int i = 0; i < 500; i++) {
+            grid.addRow(data);
+        }
+
+        ResizeTerrorizer terrorizer = new ResizeTerrorizer(grid);
+        setContent(terrorizer);
+    }
+}
diff --git a/uitest/src/com/vaadin/tests/util/ResizeTerrorizer.java b/uitest/src/com/vaadin/tests/util/ResizeTerrorizer.java
new file mode 100644
index 0000000000..679baa0d26
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/util/ResizeTerrorizer.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.tests.util;
+
+import com.vaadin.tests.widgetset.client.ResizeTerrorizerControlConnector.ResizeTerorrizerState;
+import com.vaadin.ui.AbstractComponent;
+import com.vaadin.ui.Component;
+import com.vaadin.ui.VerticalLayout;
+
+public class ResizeTerrorizer extends VerticalLayout {
+    private final ResizeTerrorizerControl control;
+
+    public class ResizeTerrorizerControl extends AbstractComponent implements
+            Component {
+
+        public ResizeTerrorizerControl(Component target) {
+            getState().target = target;
+        }
+
+        @Override
+        protected ResizeTerorrizerState getState() {
+            return (ResizeTerorrizerState) super.getState();
+        }
+    }
+
+    public ResizeTerrorizer(Component target) {
+        target.setWidth("700px");
+        setSizeFull();
+        addComponent(target);
+        setExpandRatio(target, 1);
+        control = new ResizeTerrorizerControl(target);
+        addComponent(control);
+    }
+
+    public void setDefaultWidthOffset(int px) {
+        control.getState().defaultWidthOffset = px;
+    }
+
+    public void setDefaultHeightOffset(int px) {
+        control.getState().defaultHeightOffset = px;
+    }
+
+    public void setUseUriFragments(boolean useUriFragments) {
+        control.getState().useUriFragments = useUriFragments;
+    }
+
+    public boolean isUseUriFragments() {
+        return control.getState().useUriFragments;
+    }
+}
diff --git a/uitest/src/com/vaadin/tests/widgetset/client/ResizeTerrorizerControlConnector.java b/uitest/src/com/vaadin/tests/widgetset/client/ResizeTerrorizerControlConnector.java
new file mode 100644
index 0000000000..d3a0c78948
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/widgetset/client/ResizeTerrorizerControlConnector.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.tests.widgetset.client;
+
+import java.util.Arrays;
+
+import com.google.gwt.animation.client.AnimationScheduler;
+import com.google.gwt.animation.client.AnimationScheduler.AnimationCallback;
+import com.google.gwt.event.dom.client.ClickEvent;
+import com.google.gwt.event.dom.client.ClickHandler;
+import com.google.gwt.event.dom.client.KeyCodes;
+import com.google.gwt.event.dom.client.KeyUpEvent;
+import com.google.gwt.event.dom.client.KeyUpHandler;
+import com.google.gwt.event.logical.shared.ValueChangeEvent;
+import com.google.gwt.event.logical.shared.ValueChangeHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.History;
+import com.google.gwt.user.client.ui.Button;
+import com.google.gwt.user.client.ui.FlowPanel;
+import com.google.gwt.user.client.ui.IntegerBox;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.RequiresResize;
+import com.vaadin.client.ui.AbstractComponentConnector;
+import com.vaadin.client.ui.PostLayoutListener;
+import com.vaadin.shared.AbstractComponentState;
+import com.vaadin.shared.Connector;
+import com.vaadin.shared.annotations.DelegateToWidget;
+import com.vaadin.shared.ui.Connect;
+import com.vaadin.tests.util.ResizeTerrorizer;
+
+@Connect(ResizeTerrorizer.ResizeTerrorizerControl.class)
+public class ResizeTerrorizerControlConnector extends
+        AbstractComponentConnector implements PostLayoutListener {
+
+    public static class ResizeTerorrizerState extends AbstractComponentState {
+        public Connector target;
+        public int defaultWidthOffset = 200;
+        public int defaultHeightOffset = 200;
+        @DelegateToWidget
+        public boolean useUriFragments = true;
+    }
+
+    public class ResizeTerrorizerControlPanel extends FlowPanel {
+        private Label results = new Label("Results");
+
+        private IntegerBox startWidth = new IntegerBox();
+        private IntegerBox endWidth = new IntegerBox();
+
+        private IntegerBox startHeight = new IntegerBox();
+        private IntegerBox endHeight = new IntegerBox();
+
+        private final Button terrorizeButton = new Button("Terrorize",
+                new ClickHandler() {
+                    @Override
+                    public void onClick(ClickEvent event) {
+                        terrorize(startWidth.getValue(), endWidth.getValue(),
+                                startHeight.getValue(), endHeight.getValue(),
+                                1000);
+                    }
+                });
+
+        private HandlerRegistration historyHandlerRegistration;
+
+        public ResizeTerrorizerControlPanel() {
+            add(new Label("Start width"));
+            add(startWidth);
+
+            add(new Label("End width"));
+            add(endWidth);
+
+            add(new Label("Start height"));
+            add(startHeight);
+
+            add(new Label("End height"));
+            add(endHeight);
+
+            add(terrorizeButton);
+            add(results);
+
+            startWidth.getElement().setId("terror-start-width");
+            endWidth.getElement().setId("terror-end-width");
+            terrorizeButton.getElement().setId("terror-button");
+            results.getElement().setId("terror-results");
+
+            // Emulate button click from enter on any of the text boxes
+            for (IntegerBox box : Arrays.asList(startWidth, endWidth,
+                    startHeight, endHeight)) {
+                box.addKeyUpHandler(new KeyUpHandler() {
+                    @Override
+                    public void onKeyUp(KeyUpEvent event) {
+                        if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
+                            terrorizeButton.click();
+                        }
+                    }
+                });
+            }
+        }
+
+        private void showResults(String results) {
+            Integer temp = startWidth.getValue();
+            startWidth.setValue(endWidth.getValue());
+            endWidth.setValue(temp);
+
+            temp = startHeight.getValue();
+            startHeight.setValue(endHeight.getValue());
+            endHeight.setValue(temp);
+
+            this.results.setText(results);
+
+            if (historyHandlerRegistration != null) {
+                upateHistoryToken();
+            }
+        }
+
+        public void setUseUriFragments(boolean useUriFragments) {
+            if (useUriFragments && historyHandlerRegistration == null) {
+                // First read current state
+                updateFromHistoryToken(History.getToken());
+
+                // Then add history change listener
+                historyHandlerRegistration = History
+                        .addValueChangeHandler(new ValueChangeHandler<String>() {
+                            @Override
+                            public void onValueChange(
+                                    ValueChangeEvent<String> event) {
+                                updateFromHistoryToken(event.getValue());
+                            }
+                        });
+            } else if (!useUriFragments && historyHandlerRegistration != null) {
+                historyHandlerRegistration.removeHandler();
+                historyHandlerRegistration = null;
+            }
+        }
+
+        private void updateFromHistoryToken(String token) {
+            if (token == null || token.isEmpty()) {
+                return;
+            }
+            String[] parts = token.split(",");
+            if (parts.length != 4) {
+                results.setText("Unsupported history token format: " + token);
+                return;
+            }
+
+            try {
+                startWidth.setValue(new Integer(parts[0]));
+                endWidth.setValue(new Integer(parts[1]));
+                startHeight.setValue(new Integer(parts[2]));
+                endHeight.setValue(new Integer(parts[3]));
+            } catch (NumberFormatException e) {
+                results.setText("Number format problem: " + e.getMessage());
+            }
+        }
+
+        private void upateHistoryToken() {
+            String token = startWidth.getValue().intValue() + ","
+                    + endWidth.getValue().intValue() + ","
+                    + startHeight.getValue().intValue() + ","
+                    + endHeight.getValue().intValue();
+
+            History.newItem(token, false);
+        }
+    }
+
+    private void terrorize(final double startWidth, final double endWidth,
+            final double startHeight, final double endHeight,
+            final double duration) {
+        final AbstractComponentConnector target = getTarget();
+
+        final AnimationScheduler scheduler = AnimationScheduler.get();
+        AnimationCallback callback = new AnimationCallback() {
+            double startTime = -1;
+            int frameCount = 0;
+
+            @Override
+            public void execute(double timestamp) {
+                frameCount++;
+
+                boolean done = false;
+                if (startTime == -1) {
+                    startTime = timestamp;
+                }
+
+                double time = timestamp - startTime;
+                if (time > duration) {
+                    time = duration;
+                    done = true;
+                }
+
+                double progress = time / duration;
+
+                double widthToSet = startWidth + (endWidth - startWidth)
+                        * progress;
+
+                double heightToSet = startHeight + (endHeight - startHeight)
+                        * progress;
+
+                if (widthToSet != startWidth) {
+                    target.getWidget().setWidth(widthToSet + "px");
+                }
+                if (heightToSet != startHeight) {
+                    target.getWidget().setHeight(heightToSet + "px");
+                }
+
+                // TODO Optionally inform LayoutManager as well
+                if (target.getWidget() instanceof RequiresResize) {
+                    ((RequiresResize) target.getWidget()).onResize();
+                }
+
+                if (!done) {
+                    scheduler.requestAnimationFrame(this);
+                } else {
+                    double fps = Math.round(frameCount / (duration / 1000));
+                    String results = frameCount + " frames, " + fps + " fps";
+
+                    getWidget().showResults(results);
+                }
+            }
+        };
+        scheduler.requestAnimationFrame(callback);
+    }
+
+    private AbstractComponentConnector getTarget() {
+        return (AbstractComponentConnector) getState().target;
+    }
+
+    @Override
+    public ResizeTerorrizerState getState() {
+        return (ResizeTerorrizerState) super.getState();
+    }
+
+    @Override
+    public ResizeTerrorizerControlPanel getWidget() {
+        return (ResizeTerrorizerControlPanel) super.getWidget();
+    }
+
+    @Override
+    protected ResizeTerrorizerControlPanel createWidget() {
+        return new ResizeTerrorizerControlPanel();
+    }
+
+    @Override
+    public void postLayout() {
+        if (getWidget().startWidth.getValue() == null) {
+            int width = getTarget().getWidget().getElement().getOffsetWidth();
+            getWidget().startWidth.setValue(width);
+            getWidget().endWidth
+                    .setValue(width + getState().defaultWidthOffset);
+        }
+
+        if (getWidget().startHeight.getValue() == null) {
+            int height = getTarget().getWidget().getElement().getOffsetHeight();
+            getWidget().startHeight.setValue(height);
+            getWidget().endHeight.setValue(height
+                    + getState().defaultHeightOffset);
+        }
+    }
+
+}
diff --git a/uitest/src/com/vaadin/tests/widgetset/rebind/TestWidgetRegistryGenerator.java b/uitest/src/com/vaadin/tests/widgetset/rebind/TestWidgetRegistryGenerator.java
index 1bdbba2c36..c7b29e271b 100644
--- a/uitest/src/com/vaadin/tests/widgetset/rebind/TestWidgetRegistryGenerator.java
+++ b/uitest/src/com/vaadin/tests/widgetset/rebind/TestWidgetRegistryGenerator.java
@@ -136,6 +136,9 @@ public class TestWidgetRegistryGenerator extends Generator {
         } else if (!widgetType.getPackage().getName()
                 .startsWith(TestWidgetConnector.class.getPackage().getName())) {
             return false;
+        } else if (widgetType.getEnclosingType() != null
+                && !widgetType.isStatic()) {
+            return false;
         }
 
         return true;