#8097 Root does not send resize events

src/com/vaadin/terminal/gwt/client/ui/VView.java

@@ -94,7 +94,11 @@ public class VView extends SimplePanel implements Container, ResizeHandler,
 
     private boolean resizeLazy = false;
 
+    /**
+     * Attribute name for the lazy resize setting .
+     */
     public static final String RESIZE_LAZY = "rL";
+
     /**
      * Reference to the parent frame/iframe. Null if there is no parent (i)frame
      * or if the application and parent frame are in different domains.

src/com/vaadin/ui/Root.java

@@ -30,8 +30,8 @@ import com.vaadin.terminal.WrappedRequest;
 import com.vaadin.terminal.WrappedRequest.BrowserDetails;
 import com.vaadin.terminal.gwt.client.ui.VPanel;
 import com.vaadin.terminal.gwt.client.ui.VView;
+import com.vaadin.tools.ReflectTools;
 import com.vaadin.ui.Window.CloseListener;
-import com.vaadin.ui.Window.ResizeListener;
 
 /**
  * The topmost component in any component hierarchy. There is one root for every
@@ -73,6 +73,74 @@ import com.vaadin.ui.Window.ResizeListener;
 public class Root extends AbstractComponentContainer implements
         Action.Container, Action.Notifier {
 
+    /**
+     * Listener that gets notified when the size of the browser window
+     * containing the root has changed.
+     * 
+     * @see Root#addListener(BrowserWindowResizeListener)
+     */
+    public interface BrowserWindowResizeListener extends Serializable {
+        /**
+         * Invoked when the browser window containing a Root has been resized.
+         * 
+         * @param event
+         *            a browser window resize event
+         */
+        public void browserWindowResized(BrowserWindowResizeEvent event);
+    }
+
+    /**
+     * Event that is fired when a browser window containing a root is resized.
+     */
+    public class BrowserWindowResizeEvent extends Component.Event {
+
+        private final int width;
+        private final int height;
+
+        /**
+         * Creates a new event
+         * 
+         * @param source
+         *            the root for which the browser window has been resized
+         * @param width
+         *            the new width of the browser window
+         * @param height
+         *            the new height of the browser window
+         */
+        public BrowserWindowResizeEvent(Root source, int width, int height) {
+            super(source);
+            this.width = width;
+            this.height = height;
+        }
+
+        @Override
+        public Root getSource() {
+            return (Root) super.getSource();
+        }
+
+        /**
+         * Gets the new browser window height
+         * 
+         * @return an integer with the new pixel height of the browser window
+         */
+        public int getHeight() {
+            return height;
+        }
+
+        /**
+         * Gets the new browser window width
+         * 
+         * @return an integer with the new pixel width of the browser window
+         */
+        public int getWidth() {
+            return width;
+        }
+    }
+
+    private static final Method BROWSWER_RESIZE_METHOD = ReflectTools
+            .findMethod(BrowserWindowResizeListener.class,
+                    "browserWindowResized", BrowserWindowResizeEvent.class);
+
     /**
      * Listener that listens changes in URI fragment.
      */
@@ -210,6 +278,9 @@ public class Root extends AbstractComponentContainer implements
      */
     private static final ThreadLocal<Root> currentRoot = new ThreadLocal<Root>();
 
+    private int browserWindowWidth = -1;
+    private int browserWindowHeight = -1;
+
     /**
      * Creates a new empty root without a caption. This root will have a
      * {@link VerticalLayout} with margins enabled as its content.
@@ -369,6 +440,10 @@ public class Root extends AbstractComponentContainer implements
         if (fragment != null) {
             target.addAttribute(VView.FRAGMENT_VARIABLE, fragment);
         }
+
+        if (isResizeLazy()) {
+            target.addAttribute(VView.RESIZE_LAZY, true);
+        }
     }
 
     @Override
@@ -384,6 +459,21 @@ public class Root extends AbstractComponentContainer implements
             String fragment = (String) variables.get(VView.FRAGMENT_VARIABLE);
             setFragment(fragment, true);
         }
+
+        boolean sendResizeEvent = false;
+        if (variables.containsKey("height")) {
+            browserWindowHeight = ((Integer) variables.get("height"))
+                    .intValue();
+            sendResizeEvent = true;
+        }
+        if (variables.containsKey("width")) {
+            browserWindowWidth = ((Integer) variables.get("width")).intValue();
+            sendResizeEvent = true;
+        }
+        if (sendResizeEvent) {
+            fireEvent(new BrowserWindowResizeEvent(this, browserWindowWidth,
+                    browserWindowHeight));
+        }
     }
 
     public Iterator<Component> getComponentIterator() {
@@ -541,6 +631,8 @@ public class Root extends AbstractComponentContainer implements
      */
     private String fragment;
 
+    private boolean resizeLazy = false;
+
     /**
      * This method is used by Component.Focusable objects to request focus to
      * themselves. Focus renders must be handled at window level (instead of
@@ -1162,13 +1254,26 @@ public class Root extends AbstractComponentContainer implements
      * Should resize operations be lazy, i.e. should there be a delay before
      * layout sizes are recalculated. Speeds up resize operations in slow UIs
      * with the penalty of slightly decreased usability.
+     * <p>
+     * Default value: <code>false</code>
      * 
      * @param resizeLazy
      *            true to use a delay before recalculating sizes, false to
      *            calculate immediately.
      */
     public void setResizeLazy(boolean resizeLazy) {
-        throw new RuntimeException("Not yet implemented");
+        this.resizeLazy = resizeLazy;
+        requestRepaint();
+    }
+
+    /**
+     * Checks whether lazy resize is enabled.
+     * 
+     * @return <code>true</code> if lazy resize is enabled, <code>false</code>
+     *         if lazy resize is not enabled
+     */
+    public boolean isResizeLazy() {
+        return resizeLazy;
     }
 
     /**
@@ -1255,11 +1360,51 @@ public class Root extends AbstractComponentContainer implements
         return fragment;
     }
 
-    public void addListener(ResizeListener resizeListener) {
-        throw new RuntimeException("Not yet implemented");
+    /**
+     * Adds a new {@link BrowserWindowResizeListener} to this root. The listener
+     * will be notified whenever the browser window within which this root
+     * resides is resized.
+     * 
+     * @param resizeListener
+     *            the listener to add
+     * 
+     * @see BrowserWindowResizeListener#browserWindowResized(BrowserWindowResizeEvent)
+     * @see #setResizeLazy(boolean)
+     */
+    public void addListener(BrowserWindowResizeListener resizeListener) {
+        addListener(BrowserWindowResizeEvent.class, resizeListener,
+                BROWSWER_RESIZE_METHOD);
     }
 
-    public void removeListener(ResizeListener resizeListener) {
-        throw new RuntimeException("Not yet implemented");
+    /**
+     * Removes a {@link BrowserWindowResizeListener} from this root. The
+     * listener will no longer be notified when the browser window is resized.
+     * 
+     * @param resizeListener
+     *            the listener to remove
+     */
+    public void removeListener(BrowserWindowResizeListener resizeListener) {
+        removeListener(BrowserWindowResizeEvent.class, resizeListener,
+                BROWSWER_RESIZE_METHOD);
+    }
+
+    /**
+     * Gets the last known height of the browser window in which this root
+     * resides.
+     * 
+     * @return the browser window height in pixels
+     */
+    public int getBrowserWindowHeight() {
+        return browserWindowHeight;
+    }
+
+    /**
+     * Gets the last known width of the browser window in which this root
+     * resides.
+     * 
+     * @return the browser window width in pixels
+     */
+    public int getBrowserWindowWidth() {
+        return browserWindowWidth;
     }
 }

tests/testbench/com/vaadin/tests/components/window/LazyWindowResize.java

@@ -8,6 +8,8 @@ import com.vaadin.tests.util.LoremIpsum;
 import com.vaadin.ui.CheckBox;
 import com.vaadin.ui.Label;
 import com.vaadin.ui.Root;
+import com.vaadin.ui.Root.BrowserWindowResizeEvent;
+import com.vaadin.ui.Root.BrowserWindowResizeListener;
 import com.vaadin.ui.Window;
 import com.vaadin.ui.Window.ResizeEvent;
 import com.vaadin.ui.Window.ResizeListener;
@@ -23,13 +25,13 @@ public class LazyWindowResize extends AbstractTestCase {
     protected ResizeListener resizeListener = new ResizeListener() {
 
         public void windowResized(ResizeEvent e) {
-            throw new RuntimeException("Out of order...");
-            // if (e.getWindow() == mainWindow) {
-            // log.log("Main window resized");
-            // } else {
-            // log.log("Sub window resized");
-            // }
+            log.log("Sub window resized");
+        }
+    };
 
+    protected BrowserWindowResizeListener browserWindowResizeListener = new BrowserWindowResizeListener() {
+        public void browserWindowResized(BrowserWindowResizeEvent event) {
+            log.log("Main window resized");
         }
     };
     private CheckBox immediateCheckBox;;;
@@ -71,10 +73,10 @@ public class LazyWindowResize extends AbstractTestCase {
             public void valueChange(ValueChangeEvent event) {
                 if (resizeListenerCheckBox.getValue()) {
                     subWindow.addListener(resizeListener);
-                    mainWindow.addListener(resizeListener);
+                    mainWindow.addListener(browserWindowResizeListener);
                 } else {
                     subWindow.removeListener(resizeListener);
-                    mainWindow.removeListener(resizeListener);
+                    mainWindow.removeListener(browserWindowResizeListener);
                 }
 
             }

tests/testbench/com/vaadin/tests/components/window/WindowResizeListener.java

@@ -8,9 +8,9 @@ import com.vaadin.ui.Button;
 import com.vaadin.ui.CheckBox;
 import com.vaadin.ui.Label;
 import com.vaadin.ui.Layout;
+import com.vaadin.ui.Root;
+import com.vaadin.ui.Root.BrowserWindowResizeEvent;
 import com.vaadin.ui.Window;
-import com.vaadin.ui.Window.ResizeEvent;
-import com.vaadin.ui.Window.ResizeListener;
 
 public class WindowResizeListener extends TestBase {
 
@@ -34,11 +34,11 @@ public class WindowResizeListener extends TestBase {
         final Label l = new Label();
         getLayout().addComponent(l);
 
-        getMainWindow().addListener(new ResizeListener() {
-            public void windowResized(ResizeEvent e) {
-                l.setValue("Current main window size: "
-                        + getMainWindow().getWidth() + " x "
-                        + getMainWindow().getHeight());
+        getMainWindow().addListener(new Root.BrowserWindowResizeListener() {
+            public void browserWindowResized(BrowserWindowResizeEvent event) {
+                l.setValue("Current browser window size: "
+                        + getMainWindow().getBrowserWindowWidth() + " x "
+                        + getMainWindow().getBrowserWindowHeight());
             }
         });
 

tests/testbench/com/vaadin/tests/integration/EmbedSizeTest.java

@@ -6,8 +6,7 @@ import com.vaadin.tests.components.TestBase;
 import com.vaadin.tests.util.Log;
 import com.vaadin.ui.CheckBox;
 import com.vaadin.ui.Root;
-import com.vaadin.ui.Window;
-import com.vaadin.ui.Window.ResizeEvent;
+import com.vaadin.ui.Root.BrowserWindowResizeEvent;
 
 public class EmbedSizeTest extends TestBase {
 
@@ -35,11 +34,11 @@ public class EmbedSizeTest extends TestBase {
         addComponent(lazyCheckBox);
 
         addComponent(log);
-        mainWindow.addListener(new Window.ResizeListener() {
-            public void windowResized(ResizeEvent e) {
-                Window window = e.getWindow();
-                log.log("Resize event: " + window.getWidth() + " x "
-                        + window.getHeight());
+        mainWindow.addListener(new Root.BrowserWindowResizeListener() {
+            public void browserWindowResized(BrowserWindowResizeEvent event) {
+                log.log("Resize event: " + event.getWidth() + " x "
+                        + event.getHeight());
+
             }
         });
     }