Extract API from Root to Page (#8907)

9 files changed, 1133 insertions, 722 deletions

diff --git a/src/com/vaadin/navigator/Navigator.java b/src/com/vaadin/navigator/Navigator.java
index 9d9acf9ed3..387f1d4eae 100644
--- a/src/com/vaadin/navigator/Navigator.java
+++ b/src/com/vaadin/navigator/Navigator.java
@@ -10,12 +10,13 @@ import java.util.LinkedList;
 import java.util.List;
 
 import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
+import com.vaadin.terminal.Page;
+import com.vaadin.terminal.Page.FragmentChangedEvent;
+import com.vaadin.terminal.Page.FragmentChangedListener;
 import com.vaadin.ui.Component;
 import com.vaadin.ui.CssLayout;
 import com.vaadin.ui.CustomComponent;
 import com.vaadin.ui.Root;
-import com.vaadin.ui.Root.FragmentChangedEvent;
-import com.vaadin.ui.Root.FragmentChangedListener;
 
 /**
  * Navigator utility that allows switching of views in a part of an application.
@@ -67,7 +68,7 @@ public class Navigator implements Serializable {
      */
     public static class UriFragmentManager implements FragmentManager,
             FragmentChangedListener {
-        private final Root root;
+        private final Page page;
         private final Navigator navigator;
 
         /**
@@ -80,20 +81,20 @@ public class Navigator implements Serializable {
          *            {@link Navigator} to notify of fragment changes (using
          *            {@link Navigator#navigateTo(String)}
          */
-        public UriFragmentManager(Root root, Navigator navigator) {
-            this.root = root;
+        public UriFragmentManager(Page page, Navigator navigator) {
+            this.page = page;
             this.navigator = navigator;
 
-            root.addListener(this);
+            page.addListener(this);
         }
 
         public String getFragment() {
-            return root.getFragment();
+            return page.getFragment();
         }
 
         public void setFragment(String fragment) {
             // TODO ", false" ???
-            root.setFragment(fragment);
+            page.setFragment(fragment);
         }
 
         public void fragmentChanged(FragmentChangedEvent event) {
@@ -276,9 +277,9 @@ public class Navigator implements Serializable {
      * @param display
      *            where to display the views
      */
-    public Navigator(Root root, ViewDisplay display) {
+    public Navigator(Page page, ViewDisplay display) {
         this.display = display;
-        fragmentManager = new UriFragmentManager(root, this);
+        fragmentManager = new UriFragmentManager(page, this);
     }
 
     /**
@@ -289,9 +290,9 @@ public class Navigator implements Serializable {
      * @param root
      *            whose URI fragments are used
      */
-    public Navigator(Root root) {
+    public Navigator(Page page) {
         display = new SimpleViewDisplay();
-        fragmentManager = new UriFragmentManager(root, this);
+        fragmentManager = new UriFragmentManager(page, this);
     }
 
     /**
diff --git a/src/com/vaadin/terminal/Page.java b/src/com/vaadin/terminal/Page.java
new file mode 100644
index 0000000000..65fa500d27
--- /dev/null
+++ b/src/com/vaadin/terminal/Page.java
@@ -0,0 +1,630 @@
+/* 
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.EventObject;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.vaadin.event.EventRouter;
+import com.vaadin.terminal.WrappedRequest.BrowserDetails;
+import com.vaadin.terminal.gwt.client.ui.notification.VNotification;
+import com.vaadin.terminal.gwt.client.ui.root.PageClientRpc;
+import com.vaadin.terminal.gwt.client.ui.root.VRoot;
+import com.vaadin.terminal.gwt.server.WebApplicationContext;
+import com.vaadin.terminal.gwt.server.WebBrowser;
+import com.vaadin.tools.ReflectTools;
+import com.vaadin.ui.JavaScript;
+import com.vaadin.ui.Notification;
+import com.vaadin.ui.Root;
+
+public class Page implements Serializable {
+
+    /**
+     * 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 EventObject {
+
+        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(Page source, int width, int height) {
+            super(source);
+            this.width = width;
+            this.height = height;
+        }
+
+        @Override
+        public Page getSource() {
+            return (Page) 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 class for storing properties related to opening resources.
+     */
+    private class OpenResource implements Serializable {
+
+        /**
+         * The resource to open
+         */
+        private final Resource resource;
+
+        /**
+         * The name of the target window
+         */
+        private final String name;
+
+        /**
+         * The width of the target window
+         */
+        private final int width;
+
+        /**
+         * The height of the target window
+         */
+        private final int height;
+
+        /**
+         * The border style of the target window
+         */
+        private final int border;
+
+        /**
+         * Creates a new open resource.
+         * 
+         * @param resource
+         *            The resource to open
+         * @param name
+         *            The name of the target window
+         * @param width
+         *            The width of the target window
+         * @param height
+         *            The height of the target window
+         * @param border
+         *            The border style of the target window
+         */
+        private OpenResource(Resource resource, String name, int width,
+                int height, int border) {
+            this.resource = resource;
+            this.name = name;
+            this.width = width;
+            this.height = height;
+            this.border = border;
+        }
+
+        /**
+         * Paints the open request. Should be painted inside the window.
+         * 
+         * @param target
+         *            the paint target
+         * @throws PaintException
+         *             if the paint operation fails
+         */
+        private void paintContent(PaintTarget target) throws PaintException {
+            target.startTag("open");
+            target.addAttribute("src", resource);
+            if (name != null && name.length() > 0) {
+                target.addAttribute("name", name);
+            }
+            if (width >= 0) {
+                target.addAttribute("width", width);
+            }
+            if (height >= 0) {
+                target.addAttribute("height", height);
+            }
+            switch (border) {
+            case BORDER_MINIMAL:
+                target.addAttribute("border", "minimal");
+                break;
+            case BORDER_NONE:
+                target.addAttribute("border", "none");
+                break;
+            }
+
+            target.endTag("open");
+        }
+    }
+
+    private static final Method BROWSWER_RESIZE_METHOD = ReflectTools
+            .findMethod(BrowserWindowResizeListener.class,
+                    "browserWindowResized", BrowserWindowResizeEvent.class);
+
+    /**
+     * A border style used for opening resources in a window without a border.
+     */
+    public static final int BORDER_NONE = 0;
+
+    /**
+     * A border style used for opening resources in a window with a minimal
+     * border.
+     */
+    public static final int BORDER_MINIMAL = 1;
+
+    /**
+     * A border style that indicates that the default border style should be
+     * used when opening resources.
+     */
+    public static final int BORDER_DEFAULT = 2;
+
+    /**
+     * Listener that listens changes in URI fragment.
+     */
+    public interface FragmentChangedListener extends Serializable {
+        public void fragmentChanged(FragmentChangedEvent event);
+    }
+
+    private static final Method FRAGMENT_CHANGED_METHOD = ReflectTools
+            .findMethod(Page.FragmentChangedListener.class, "fragmentChanged",
+                    FragmentChangedEvent.class);
+
+    /**
+     * Resources to be opened automatically on next repaint. The list is
+     * automatically cleared when it has been sent to the client.
+     */
+    private final LinkedList<OpenResource> openList = new LinkedList<OpenResource>();
+
+    /**
+     * A list of notifications that are waiting to be sent to the client.
+     * Cleared (set to null) when the notifications have been sent.
+     */
+    private List<Notification> notifications;
+
+    /**
+     * Event fired when uri fragment changes.
+     */
+    public class FragmentChangedEvent extends EventObject {
+
+        /**
+         * The new uri fragment
+         */
+        private final String fragment;
+
+        /**
+         * Creates a new instance of UriFragmentReader change event.
+         * 
+         * @param source
+         *            the Source of the event.
+         */
+        public FragmentChangedEvent(Page source, String fragment) {
+            super(source);
+            this.fragment = fragment;
+        }
+
+        /**
+         * Gets the root in which the fragment has changed.
+         * 
+         * @return the root in which the fragment has changed
+         */
+        public Page getPage() {
+            return (Page) getSource();
+        }
+
+        /**
+         * Get the new fragment
+         * 
+         * @return the new fragment
+         */
+        public String getFragment() {
+            return fragment;
+        }
+    }
+
+    private EventRouter eventRouter;
+
+    /**
+     * The current URI fragment.
+     */
+    private String fragment;
+
+    private final Root root;
+
+    private int browserWindowWidth = -1;
+    private int browserWindowHeight = -1;
+
+    private JavaScript javaScript;
+
+    public Page(Root root) {
+        this.root = root;
+    }
+
+    private void addListener(Class<?> eventType, Object target, Method method) {
+        if (eventRouter == null) {
+            eventRouter = new EventRouter();
+        }
+        eventRouter.addListener(eventType, target, method);
+    }
+
+    private void removeListener(Class<?> eventType, Object target, Method method) {
+        if (eventRouter != null) {
+            eventRouter.removeListener(eventType, target, method);
+        }
+    }
+
+    public void addListener(Page.FragmentChangedListener listener) {
+        addListener(FragmentChangedEvent.class, listener,
+                FRAGMENT_CHANGED_METHOD);
+    }
+
+    public void removeListener(Page.FragmentChangedListener listener) {
+        removeListener(FragmentChangedEvent.class, listener,
+                FRAGMENT_CHANGED_METHOD);
+    }
+
+    /**
+     * Sets URI fragment. Optionally fires a {@link FragmentChangedEvent}
+     * 
+     * @param newFragment
+     *            id of the new fragment
+     * @param fireEvent
+     *            true to fire event
+     * @see FragmentChangedEvent
+     * @see Page.FragmentChangedListener
+     */
+    public void setFragment(String newFragment, boolean fireEvents) {
+        if (newFragment == null) {
+            throw new NullPointerException("The fragment may not be null");
+        }
+        if (!newFragment.equals(fragment)) {
+            fragment = newFragment;
+            if (fireEvents) {
+                fireEvent(new FragmentChangedEvent(this, newFragment));
+            }
+            root.requestRepaint();
+        }
+    }
+
+    private void fireEvent(EventObject event) {
+        if (eventRouter != null) {
+            eventRouter.fireEvent(event);
+        }
+    }
+
+    /**
+     * Sets URI fragment. This method fires a {@link FragmentChangedEvent}
+     * 
+     * @param newFragment
+     *            id of the new fragment
+     * @see FragmentChangedEvent
+     * @see Page.FragmentChangedListener
+     */
+    public void setFragment(String newFragment) {
+        setFragment(newFragment, true);
+    }
+
+    /**
+     * Gets currently set URI fragment.
+     * <p>
+     * To listen changes in fragment, hook a
+     * {@link Page.FragmentChangedListener}.
+     * 
+     * @return the current fragment in browser uri or null if not known
+     */
+    public String getFragment() {
+        return fragment;
+    }
+
+    public void init(WrappedRequest request) {
+        BrowserDetails browserDetails = request.getBrowserDetails();
+        if (browserDetails != null) {
+            fragment = browserDetails.getUriFragment();
+        }
+    }
+
+    public WebBrowser getWebBrowser() {
+        return ((WebApplicationContext) root.getApplication().getContext())
+                .getBrowser();
+    }
+
+    public void setBrowserWindowSize(Integer width, Integer height) {
+        boolean fireEvent = false;
+
+        if (width != null) {
+            int newWidth = width.intValue();
+            if (newWidth != browserWindowWidth) {
+                browserWindowWidth = newWidth;
+                fireEvent = true;
+            }
+        }
+
+        if (height != null) {
+            int newHeight = height.intValue();
+            if (newHeight != browserWindowHeight) {
+                browserWindowHeight = newHeight;
+                fireEvent = true;
+            }
+        }
+
+        if (fireEvent) {
+            fireEvent(new BrowserWindowResizeEvent(this, browserWindowWidth,
+                    browserWindowHeight));
+        }
+
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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;
+    }
+
+    public JavaScript getJavaScript() {
+        if (javaScript == null) {
+            // Create and attach on first use
+            javaScript = new JavaScript();
+            javaScript.extend(root);
+        }
+
+        return javaScript;
+    }
+
+    public void paintContent(PaintTarget target) throws PaintException {
+        if (!openList.isEmpty()) {
+            for (final Iterator<OpenResource> i = openList.iterator(); i
+                    .hasNext();) {
+                (i.next()).paintContent(target);
+            }
+            openList.clear();
+        }
+
+        // Paint notifications
+        if (notifications != null) {
+            target.startTag("notifications");
+            for (final Iterator<Notification> it = notifications.iterator(); it
+                    .hasNext();) {
+                final Notification n = it.next();
+                target.startTag("notification");
+                if (n.getCaption() != null) {
+                    target.addAttribute(
+                            VNotification.ATTRIBUTE_NOTIFICATION_CAPTION,
+                            n.getCaption());
+                }
+                if (n.getDescription() != null) {
+                    target.addAttribute(
+                            VNotification.ATTRIBUTE_NOTIFICATION_MESSAGE,
+                            n.getDescription());
+                }
+                if (n.getIcon() != null) {
+                    target.addAttribute(
+                            VNotification.ATTRIBUTE_NOTIFICATION_ICON,
+                            n.getIcon());
+                }
+                if (!n.isHtmlContentAllowed()) {
+                    target.addAttribute(
+                            VRoot.NOTIFICATION_HTML_CONTENT_NOT_ALLOWED, true);
+                }
+                target.addAttribute(
+                        VNotification.ATTRIBUTE_NOTIFICATION_POSITION,
+                        n.getPosition());
+                target.addAttribute(VNotification.ATTRIBUTE_NOTIFICATION_DELAY,
+                        n.getDelayMsec());
+                if (n.getStyleName() != null) {
+                    target.addAttribute(
+                            VNotification.ATTRIBUTE_NOTIFICATION_STYLE,
+                            n.getStyleName());
+                }
+                target.endTag("notification");
+            }
+            target.endTag("notifications");
+            notifications = null;
+        }
+
+        if (fragment != null) {
+            target.addAttribute(VRoot.FRAGMENT_VARIABLE, fragment);
+        }
+
+    }
+
+    /**
+     * Opens the given resource in this root. The contents of this Root is
+     * replaced by the {@code Resource}.
+     * 
+     * @param resource
+     *            the resource to show in this root
+     */
+    public void open(Resource resource) {
+        openList.add(new OpenResource(resource, null, -1, -1, BORDER_DEFAULT));
+        root.requestRepaint();
+    }
+
+    /**
+     * Opens the given resource in a window with the given name.
+     * <p>
+     * The supplied {@code windowName} is used as the target name in a
+     * window.open call in the client. This means that special values such as
+     * "_blank", "_self", "_top", "_parent" have special meaning. An empty or
+     * <code>null</code> window name is also a special case.
+     * </p>
+     * <p>
+     * "", null and "_self" as {@code windowName} all causes the resource to be
+     * opened in the current window, replacing any old contents. For
+     * downloadable content you should avoid "_self" as "_self" causes the
+     * client to skip rendering of any other changes as it considers them
+     * irrelevant (the page will be replaced by the resource). This can speed up
+     * the opening of a resource, but it might also put the client side into an
+     * inconsistent state if the window content is not completely replaced e.g.,
+     * if the resource is downloaded instead of displayed in the browser.
+     * </p>
+     * <p>
+     * "_blank" as {@code windowName} causes the resource to always be opened in
+     * a new window or tab (depends on the browser and browser settings).
+     * </p>
+     * <p>
+     * "_top" and "_parent" as {@code windowName} works as specified by the HTML
+     * standard.
+     * </p>
+     * <p>
+     * Any other {@code windowName} will open the resource in a window with that
+     * name, either by opening a new window/tab in the browser or by replacing
+     * the contents of an existing window with that name.
+     * </p>
+     * 
+     * @param resource
+     *            the resource.
+     * @param windowName
+     *            the name of the window.
+     */
+    public void open(Resource resource, String windowName) {
+        openList.add(new OpenResource(resource, windowName, -1, -1,
+                BORDER_DEFAULT));
+        root.requestRepaint();
+    }
+
+    /**
+     * Opens the given resource in a window with the given size, border and
+     * name. For more information on the meaning of {@code windowName}, see
+     * {@link #open(Resource, String)}.
+     * 
+     * @param resource
+     *            the resource.
+     * @param windowName
+     *            the name of the window.
+     * @param width
+     *            the width of the window in pixels
+     * @param height
+     *            the height of the window in pixels
+     * @param border
+     *            the border style of the window. See {@link #BORDER_NONE
+     *            Window.BORDER_* constants}
+     */
+    public void open(Resource resource, String windowName, int width,
+            int height, int border) {
+        openList.add(new OpenResource(resource, windowName, width, height,
+                border));
+        root.requestRepaint();
+    }
+
+    /**
+     * Internal helper method to actually add a notification.
+     * 
+     * @param notification
+     *            the notification to add
+     */
+    private void addNotification(Notification notification) {
+        if (notifications == null) {
+            notifications = new LinkedList<Notification>();
+        }
+        notifications.add(notification);
+        root.requestRepaint();
+    }
+
+    /**
+     * Shows a notification message.
+     * 
+     * @see Notification
+     * @see #showNotification(String)
+     * @see #showNotification(String, int)
+     * @see #showNotification(String, String)
+     * @see #showNotification(String, String, int)
+     * 
+     * @param notification
+     *            The notification message to show
+     */
+    public void showNotification(Notification notification) {
+        addNotification(notification);
+    }
+
+    public static Page getCurrent() {
+        Root currentRoot = Root.getCurrentRoot();
+        if (currentRoot == null) {
+            return null;
+        }
+        return currentRoot.getPage();
+    }
+
+    public void setTitle(String title) {
+        root.getRpcProxy(PageClientRpc.class).setTitle(title);
+    }
+
+}
diff --git a/src/com/vaadin/terminal/gwt/client/ui/root/PageClientRpc.java b/src/com/vaadin/terminal/gwt/client/ui/root/PageClientRpc.java
new file mode 100644
index 0000000000..a02ecc8ded
--- /dev/null
+++ b/src/com/vaadin/terminal/gwt/client/ui/root/PageClientRpc.java
@@ -0,0 +1,13 @@
+/* 
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui.root;
+
+import com.vaadin.terminal.gwt.client.communication.ClientRpc;
+
+public interface PageClientRpc extends ClientRpc {
+
+    public void setTitle(String title);
+
+}
diff --git a/src/com/vaadin/terminal/gwt/client/ui/root/RootConnector.java b/src/com/vaadin/terminal/gwt/client/ui/root/RootConnector.java
index eebbe971a4..5184f38ed9 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/root/RootConnector.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/root/RootConnector.java
@@ -61,6 +61,11 @@ public class RootConnector extends AbstractComponentContainerConnector
     @Override
     protected void init() {
         super.init();
+        registerRpc(PageClientRpc.class, new PageClientRpc() {
+            public void setTitle(String title) {
+                com.google.gwt.user.client.Window.setTitle(title);
+            }
+        });
     }
 
     public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
@@ -95,11 +100,6 @@ public class RootConnector extends AbstractComponentContainerConnector
 
         clickEventHandler.handleEventHandlerRegistration();
 
-        if (!getWidget().isEmbedded() && getState().getCaption() != null) {
-            // only change window title if we're in charge of the whole page
-            com.google.gwt.user.client.Window.setTitle(getState().getCaption());
-        }
-
         // Process children
         int childIndex = 0;
 
diff --git a/src/com/vaadin/ui/HelloWorldExtension.java b/src/com/vaadin/ui/HelloWorldExtension.java
index 6d9ce9bcf1..e705954f2e 100644
--- a/src/com/vaadin/ui/HelloWorldExtension.java
+++ b/src/com/vaadin/ui/HelloWorldExtension.java
@@ -13,7 +13,7 @@ public class HelloWorldExtension extends AbstractExtension {
     public HelloWorldExtension() {
         registerRpc(new HelloWorldRpc() {
             public void onMessageSent(String message) {
-                getRoot().showNotification(message);
+                Notification.show(message);
             }
         });
     }
diff --git a/src/com/vaadin/ui/JavaScript.java b/src/com/vaadin/ui/JavaScript.java
index 234f37f8a6..241d477506 100644
--- a/src/com/vaadin/ui/JavaScript.java
+++ b/src/com/vaadin/ui/JavaScript.java
@@ -10,6 +10,7 @@ import java.util.Map;
 import com.vaadin.external.json.JSONArray;
 import com.vaadin.external.json.JSONException;
 import com.vaadin.terminal.AbstractExtension;
+import com.vaadin.terminal.Page;
 import com.vaadin.terminal.gwt.client.communication.ServerRpc;
 import com.vaadin.terminal.gwt.client.extensions.javascriptmanager.ExecuteJavaScriptRpc;
 import com.vaadin.terminal.gwt.client.extensions.javascriptmanager.JavaScriptManagerState;
@@ -61,7 +62,11 @@ public class JavaScript extends AbstractExtension {
     }
 
     public static JavaScript getCurrent() {
-        return Root.getCurrentRoot().getJavaScript();
+        Page page = Page.getCurrent();
+        if (page == null) {
+            return null;
+        }
+        return page.getJavaScript();
     }
 
 }
diff --git a/src/com/vaadin/ui/Link.java b/src/com/vaadin/ui/Link.java
index ed5ffbba3a..db0dc58e6b 100644
--- a/src/com/vaadin/ui/Link.java
+++ b/src/com/vaadin/ui/Link.java
@@ -6,6 +6,7 @@ package com.vaadin.ui;
 
 import java.util.Map;
 
+import com.vaadin.terminal.Page;
 import com.vaadin.terminal.PaintException;
 import com.vaadin.terminal.PaintTarget;
 import com.vaadin.terminal.Resource;
@@ -23,13 +24,13 @@ import com.vaadin.terminal.Vaadin6Component;
 public class Link extends AbstractComponent implements Vaadin6Component {
 
     /* Target window border type constant: No window border */
-    public static final int TARGET_BORDER_NONE = Root.BORDER_NONE;
+    public static final int TARGET_BORDER_NONE = Page.BORDER_NONE;
 
     /* Target window border type constant: Minimal window border */
-    public static final int TARGET_BORDER_MINIMAL = Root.BORDER_MINIMAL;
+    public static final int TARGET_BORDER_MINIMAL = Page.BORDER_MINIMAL;
 
     /* Target window border type constant: Default window border */
-    public static final int TARGET_BORDER_DEFAULT = Root.BORDER_DEFAULT;
+    public static final int TARGET_BORDER_DEFAULT = Page.BORDER_DEFAULT;
 
     private Resource resource = null;
 
diff --git a/src/com/vaadin/ui/Notification.java b/src/com/vaadin/ui/Notification.java
index bb1f874635..075ab50196 100644
--- a/src/com/vaadin/ui/Notification.java
+++ b/src/com/vaadin/ui/Notification.java
@@ -6,6 +6,7 @@ package com.vaadin.ui;
 
 import java.io.Serializable;
 
+import com.vaadin.terminal.Page;
 import com.vaadin.terminal.Resource;
 
 /**
@@ -318,4 +319,118 @@ public class Notification implements Serializable {
     public boolean isHtmlContentAllowed() {
         return htmlContentAllowed;
     }
+
+    public void show() {
+        Page.getCurrent().showNotification(this);
+    }
+
+    /**
+     * Shows a notification message on the middle of the current page. The
+     * message automatically disappears ("humanized message").
+     * 
+     * Care should be taken to to avoid XSS vulnerabilities as the caption is
+     * rendered as html.
+     * 
+     * @see #showNotification(Notification)
+     * @see Notification
+     * 
+     * @param caption
+     *            The message
+     */
+    public static void show(String caption) {
+        new Notification(caption).show();
+    }
+
+    /**
+     * Shows a notification message the current page. The position and behavior
+     * of the message depends on the type, which is one of the basic types
+     * defined in {@link Notification}, for instance
+     * Notification.TYPE_WARNING_MESSAGE.
+     * 
+     * Care should be taken to to avoid XSS vulnerabilities as the caption is
+     * rendered as html.
+     * 
+     * @see #showNotification(Notification)
+     * @see Notification
+     * 
+     * @param caption
+     *            The message
+     * @param type
+     *            The message type
+     */
+    public static void show(String caption, int type) {
+        new Notification(caption, type).show();
+    }
+
+    /**
+     * Shows a notification consisting of a bigger caption and a smaller
+     * description on the middle of the current page. The message automatically
+     * disappears ("humanized message").
+     * 
+     * Care should be taken to to avoid XSS vulnerabilities as the caption and
+     * description are rendered as html.
+     * 
+     * @see #showNotification(Notification)
+     * @see Notification
+     * 
+     * @param caption
+     *            The caption of the message
+     * @param description
+     *            The message description
+     * 
+     */
+    public static void show(String caption, String description) {
+        new Notification(caption, description).show();
+    }
+
+    /**
+     * Shows a notification consisting of a bigger caption and a smaller
+     * description. The position and behavior of the message depends on the
+     * type, which is one of the basic types defined in {@link Notification},
+     * for instance Notification.TYPE_WARNING_MESSAGE.
+     * 
+     * Care should be taken to to avoid XSS vulnerabilities as the caption and
+     * description are rendered as html.
+     * 
+     * @see #showNotification(Notification)
+     * @see Notification
+     * 
+     * @param caption
+     *            The caption of the message
+     * @param description
+     *            The message description
+     * @param type
+     *            The message type
+     */
+    public static void show(String caption, String description, int type) {
+
+        new Notification(caption, description, type).show();
+    }
+
+    /**
+     * Shows a notification consisting of a bigger caption and a smaller
+     * description. The position and behavior of the message depends on the
+     * type, which is one of the basic types defined in {@link Notification},
+     * for instance Notification.TYPE_WARNING_MESSAGE.
+     * 
+     * Care should be taken to avoid XSS vulnerabilities if html content is
+     * allowed.
+     * 
+     * @see #showNotification(Notification)
+     * @see Notification
+     * 
+     * @param caption
+     *            The message caption
+     * @param description
+     *            The message description
+     * @param type
+     *            The type of message
+     * @param htmlContentAllowed
+     *            Whether html in the caption and description should be
+     *            displayed as html or as plain text
+     */
+    public static void show(String caption, String description, int type,
+            boolean htmlContentAllowed) {
+        new Notification(caption, description, type, htmlContentAllowed).show();
+    }
 }
\ No newline at end of file
diff --git a/src/com/vaadin/ui/Root.java b/src/com/vaadin/ui/Root.java
index 60408fe1dc..50ad99571e 100644
--- a/src/com/vaadin/ui/Root.java
+++ b/src/com/vaadin/ui/Root.java
@@ -4,8 +4,6 @@
 
 package com.vaadin.ui;
 
-import java.io.Serializable;
-import java.lang.reflect.Method;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -13,8 +11,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
 import java.util.Map;
 
 import com.vaadin.Application;
@@ -24,6 +20,9 @@ import com.vaadin.event.Action.Handler;
 import com.vaadin.event.ActionManager;
 import com.vaadin.event.MouseEvents.ClickEvent;
 import com.vaadin.event.MouseEvents.ClickListener;
+import com.vaadin.terminal.Page;
+import com.vaadin.terminal.Page.BrowserWindowResizeEvent;
+import com.vaadin.terminal.Page.BrowserWindowResizeListener;
 import com.vaadin.terminal.PaintException;
 import com.vaadin.terminal.PaintTarget;
 import com.vaadin.terminal.Resource;
@@ -31,11 +30,9 @@ import com.vaadin.terminal.Vaadin6Component;
 import com.vaadin.terminal.WrappedRequest;
 import com.vaadin.terminal.WrappedRequest.BrowserDetails;
 import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.notification.VNotification;
 import com.vaadin.terminal.gwt.client.ui.root.RootServerRpc;
 import com.vaadin.terminal.gwt.client.ui.root.RootState;
 import com.vaadin.terminal.gwt.client.ui.root.VRoot;
-import com.vaadin.tools.ReflectTools;
 import com.vaadin.ui.Window.CloseListener;
 
 /**
@@ -79,121 +76,6 @@ public abstract class Root extends AbstractComponentContainer implements
         Action.Container, Action.Notifier, Vaadin6Component {
 
     /**
-     * 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.
-     */
-    public interface FragmentChangedListener extends Serializable {
-        public void fragmentChanged(FragmentChangedEvent event);
-    }
-
-    /**
-     * Event fired when uri fragment changes.
-     */
-    public class FragmentChangedEvent extends Component.Event {
-
-        /**
-         * The new uri fragment
-         */
-        private final String fragment;
-
-        /**
-         * Creates a new instance of UriFragmentReader change event.
-         * 
-         * @param source
-         *            the Source of the event.
-         */
-        public FragmentChangedEvent(Root source, String fragment) {
-            super(source);
-            this.fragment = fragment;
-        }
-
-        /**
-         * Gets the root in which the fragment has changed.
-         * 
-         * @return the root in which the fragment has changed
-         */
-        public Root getRoot() {
-            return (Root) getComponent();
-        }
-
-        /**
-         * Get the new fragment
-         * 
-         * @return the new fragment
-         */
-        public String getFragment() {
-            return fragment;
-        }
-    }
-
-    /**
      * Helper class to emulate the main window from Vaadin 6 using roots. This
      * class should be used in the same way as Window used as a browser level
      * window in Vaadin 6 with {@link com.vaadin.Application.LegacyApplication}
@@ -312,38 +194,332 @@ public abstract class Root extends AbstractComponentContainer implements
                         "Internal problem getting window URL, please report");
             }
         }
-    }
 
-    private static final Method FRAGMENT_CHANGED_METHOD;
-
-    static {
-        try {
-            FRAGMENT_CHANGED_METHOD = FragmentChangedListener.class
-                    .getDeclaredMethod("fragmentChanged",
-                            new Class[] { FragmentChangedEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
-            // This should never happen
-            throw new java.lang.RuntimeException(
-                    "Internal error finding methods in FragmentChangedListener");
+        /**
+         * Opens the given resource in this root. The contents of this Root is
+         * replaced by the {@code Resource}.
+         * 
+         * @param resource
+         *            the resource to show in this root
+         * 
+         * @deprecated As of 7.0, use getPage().open instead
+         */
+        @Deprecated
+        public void open(Resource resource) {
+            getPage().open(resource);
         }
-    }
 
-    /**
-     * A border style used for opening resources in a window without a border.
-     */
-    public static final int BORDER_NONE = 0;
+        /* ********************************************************************* */
 
-    /**
-     * A border style used for opening resources in a window with a minimal
-     * border.
-     */
-    public static final int BORDER_MINIMAL = 1;
+        /**
+         * Opens the given resource in a window with the given name.
+         * <p>
+         * The supplied {@code windowName} is used as the target name in a
+         * window.open call in the client. This means that special values such
+         * as "_blank", "_self", "_top", "_parent" have special meaning. An
+         * empty or <code>null</code> window name is also a special case.
+         * </p>
+         * <p>
+         * "", null and "_self" as {@code windowName} all causes the resource to
+         * be opened in the current window, replacing any old contents. For
+         * downloadable content you should avoid "_self" as "_self" causes the
+         * client to skip rendering of any other changes as it considers them
+         * irrelevant (the page will be replaced by the resource). This can
+         * speed up the opening of a resource, but it might also put the client
+         * side into an inconsistent state if the window content is not
+         * completely replaced e.g., if the resource is downloaded instead of
+         * displayed in the browser.
+         * </p>
+         * <p>
+         * "_blank" as {@code windowName} causes the resource to always be
+         * opened in a new window or tab (depends on the browser and browser
+         * settings).
+         * </p>
+         * <p>
+         * "_top" and "_parent" as {@code windowName} works as specified by the
+         * HTML standard.
+         * </p>
+         * <p>
+         * Any other {@code windowName} will open the resource in a window with
+         * that name, either by opening a new window/tab in the browser or by
+         * replacing the contents of an existing window with that name.
+         * </p>
+         * 
+         * @param resource
+         *            the resource.
+         * @param windowName
+         *            the name of the window.
+         * @deprecated As of 7.0, use getPage().open instead
+         */
+        @Deprecated
+        public void open(Resource resource, String windowName) {
+            getPage().open(resource, windowName);
+        }
 
-    /**
-     * A border style that indicates that the default border style should be
-     * used when opening resources.
-     */
-    public static final int BORDER_DEFAULT = 2;
+        /**
+         * Opens the given resource in a window with the given size, border and
+         * name. For more information on the meaning of {@code windowName}, see
+         * {@link #open(Resource, String)}.
+         * 
+         * @param resource
+         *            the resource.
+         * @param windowName
+         *            the name of the window.
+         * @param width
+         *            the width of the window in pixels
+         * @param height
+         *            the height of the window in pixels
+         * @param border
+         *            the border style of the window. See {@link #BORDER_NONE
+         *            Window.BORDER_* constants}
+         * @deprecated As of 7.0, use getPage().open instead
+         */
+        @Deprecated
+        public void open(Resource resource, String windowName, int width,
+                int height, int border) {
+            getPage().open(resource, windowName, width, height, border);
+        }
+
+        /**
+         * 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)
+         * 
+         * @deprecated As of 7.0, use the similarly named api in Page instead
+         */
+        @Deprecated
+        public void addListener(BrowserWindowResizeListener resizeListener) {
+            getPage().addListener(resizeListener);
+        }
+
+        /**
+         * 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
+         * @deprecated As of 7.0, use the similarly named api in Page instead
+         */
+        @Deprecated
+        public void removeListener(BrowserWindowResizeListener resizeListener) {
+            getPage().removeListener(resizeListener);
+        }
+
+        /**
+         * Gets the last known height of the browser window in which this root
+         * resides.
+         * 
+         * @return the browser window height in pixels
+         * @deprecated As of 7.0, use the similarly named api in Page instead
+         */
+        @Deprecated
+        public int getBrowserWindowHeight() {
+            return getPage().getBrowserWindowHeight();
+        }
+
+        /**
+         * Gets the last known width of the browser window in which this root
+         * resides.
+         * 
+         * @return the browser window width in pixels
+         * 
+         * @deprecated As of 7.0, use the similarly named api in Page instead
+         */
+        @Deprecated
+        public int getBrowserWindowWidth() {
+            return getPage().getBrowserWindowWidth();
+        }
+
+        /**
+         * Shows a notification message on the middle of the root. The message
+         * automatically disappears ("humanized message").
+         * 
+         * Care should be taken to to avoid XSS vulnerabilities as the caption
+         * is rendered as html.
+         * 
+         * @see #showNotification(Notification)
+         * @see Notification
+         * 
+         * @param caption
+         *            The message
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(String caption) {
+            getPage().showNotification(new Notification(caption));
+        }
+
+        /**
+         * Shows a notification message the root. The position and behavior of
+         * the message depends on the type, which is one of the basic types
+         * defined in {@link Notification}, for instance
+         * Notification.TYPE_WARNING_MESSAGE.
+         * 
+         * Care should be taken to to avoid XSS vulnerabilities as the caption
+         * is rendered as html.
+         * 
+         * @see #showNotification(Notification)
+         * @see Notification
+         * 
+         * @param caption
+         *            The message
+         * @param type
+         *            The message type
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(String caption, int type) {
+            getPage().showNotification(new Notification(caption, type));
+        }
+
+        /**
+         * Shows a notification consisting of a bigger caption and a smaller
+         * description on the middle of the root. The message automatically
+         * disappears ("humanized message").
+         * 
+         * Care should be taken to to avoid XSS vulnerabilities as the caption
+         * and description are rendered as html.
+         * 
+         * @see #showNotification(Notification)
+         * @see Notification
+         * 
+         * @param caption
+         *            The caption of the message
+         * @param description
+         *            The message description
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(String caption, String description) {
+            getPage().showNotification(new Notification(caption, description));
+        }
+
+        /**
+         * Shows a notification consisting of a bigger caption and a smaller
+         * description. The position and behavior of the message depends on the
+         * type, which is one of the basic types defined in {@link Notification}
+         * , for instance Notification.TYPE_WARNING_MESSAGE.
+         * 
+         * Care should be taken to to avoid XSS vulnerabilities as the caption
+         * and description are rendered as html.
+         * 
+         * @see #showNotification(Notification)
+         * @see Notification
+         * 
+         * @param caption
+         *            The caption of the message
+         * @param description
+         *            The message description
+         * @param type
+         *            The message type
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(String caption, String description,
+                int type) {
+            getPage().showNotification(
+                    new Notification(caption, description, type));
+        }
+
+        /**
+         * Shows a notification consisting of a bigger caption and a smaller
+         * description. The position and behavior of the message depends on the
+         * type, which is one of the basic types defined in {@link Notification}
+         * , for instance Notification.TYPE_WARNING_MESSAGE.
+         * 
+         * Care should be taken to avoid XSS vulnerabilities if html content is
+         * allowed.
+         * 
+         * @see #showNotification(Notification)
+         * @see Notification
+         * 
+         * @param caption
+         *            The message caption
+         * @param description
+         *            The message description
+         * @param type
+         *            The type of message
+         * @param htmlContentAllowed
+         *            Whether html in the caption and description should be
+         *            displayed as html or as plain text
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(String caption, String description,
+                int type, boolean htmlContentAllowed) {
+            getPage().showNotification(
+                    new Notification(caption, description, type,
+                            htmlContentAllowed));
+        }
+
+        /**
+         * Shows a notification message.
+         * 
+         * @see Notification
+         * @see #showNotification(String)
+         * @see #showNotification(String, int)
+         * @see #showNotification(String, String)
+         * @see #showNotification(String, String, int)
+         * 
+         * @param notification
+         *            The notification message to show
+         * 
+         * @deprecated As of 7.0, use Notification.show instead
+         */
+        @Deprecated
+        public void showNotification(Notification notification) {
+            getPage().showNotification(notification);
+        }
+
+        /**
+         * Executes JavaScript in this window.
+         * 
+         * <p>
+         * This method allows one to inject javascript from the server to
+         * client. A client implementation is not required to implement this
+         * functionality, but currently all web-based clients do implement this.
+         * </p>
+         * 
+         * <p>
+         * Executing javascript this way often leads to cross-browser
+         * compatibility issues and regressions that are hard to resolve. Use of
+         * this method should be avoided and instead it is recommended to create
+         * new widgets with GWT. For more info on creating own, reusable
+         * client-side widgets in Java, read the corresponding chapter in Book
+         * of Vaadin.
+         * </p>
+         * 
+         * @param script
+         *            JavaScript snippet that will be executed.
+         * 
+         * @deprecated as of 7.0, use JavaScript.getCurrent().execute(String)
+         *             instead
+         */
+        @Deprecated
+        public void executeJavaScript(String script) {
+            getPage().getJavaScript().execute(script);
+        }
+
+        @Override
+        public void setCaption(String caption) {
+            // Override to provide backwards compatibility
+            getState().setCaption(caption);
+            getPage().setTitle(caption);
+        }
+
+    }
 
     /**
      * The application to which this root belongs
@@ -351,23 +527,11 @@ public abstract class Root extends AbstractComponentContainer implements
     private Application application;
 
     /**
-     * A list of notifications that are waiting to be sent to the client.
-     * Cleared (set to null) when the notifications have been sent.
-     */
-    private List<Notification> notifications;
-
-    /**
      * List of windows in this root.
      */
     private final LinkedHashSet<Window> windows = new LinkedHashSet<Window>();
 
     /**
-     * Resources to be opened automatically on next repaint. The list is
-     * automatically cleared when it has been sent to the client.
-     */
-    private final LinkedList<OpenResource> openList = new LinkedList<OpenResource>();
-
-    /**
      * The component that should be scrolled into view after the next repaint.
      * Null if nothing should be scrolled into view.
      */
@@ -393,16 +557,13 @@ public abstract class Root extends AbstractComponentContainer implements
      */
     private static final ThreadLocal<Root> currentRoot = new ThreadLocal<Root>();
 
-    private int browserWindowWidth = -1;
-    private int browserWindowHeight = -1;
-
     /** Identifies the click event */
     private static final String CLICK_EVENT_ID = VRoot.CLICK_EVENT_ID;
 
     private DirtyConnectorTracker dirtyConnectorTracker = new DirtyConnectorTracker(
             this);
 
-    private JavaScript javaScript;
+    private Page page = new Page(this);
 
     private RootServerRpc rpc = new RootServerRpc() {
         public void click(MouseEventDetails mouseDetails) {
@@ -498,58 +659,7 @@ public abstract class Root extends AbstractComponentContainer implements
     }
 
     public void paintContent(PaintTarget target) throws PaintException {
-        // Open requested resource
-        synchronized (openList) {
-            if (!openList.isEmpty()) {
-                for (final Iterator<OpenResource> i = openList.iterator(); i
-                        .hasNext();) {
-                    (i.next()).paintContent(target);
-                }
-                openList.clear();
-            }
-        }
-
-        // Paint notifications
-        if (notifications != null) {
-            target.startTag("notifications");
-            for (final Iterator<Notification> it = notifications.iterator(); it
-                    .hasNext();) {
-                final Notification n = it.next();
-                target.startTag("notification");
-                if (n.getCaption() != null) {
-                    target.addAttribute(
-                            VNotification.ATTRIBUTE_NOTIFICATION_CAPTION,
-                            n.getCaption());
-                }
-                if (n.getDescription() != null) {
-                    target.addAttribute(
-                            VNotification.ATTRIBUTE_NOTIFICATION_MESSAGE,
-                            n.getDescription());
-                }
-                if (n.getIcon() != null) {
-                    target.addAttribute(
-                            VNotification.ATTRIBUTE_NOTIFICATION_ICON,
-                            n.getIcon());
-                }
-                if (!n.isHtmlContentAllowed()) {
-                    target.addAttribute(
-                            VRoot.NOTIFICATION_HTML_CONTENT_NOT_ALLOWED, true);
-                }
-                target.addAttribute(
-                        VNotification.ATTRIBUTE_NOTIFICATION_POSITION,
-                        n.getPosition());
-                target.addAttribute(VNotification.ATTRIBUTE_NOTIFICATION_DELAY,
-                        n.getDelayMsec());
-                if (n.getStyleName() != null) {
-                    target.addAttribute(
-                            VNotification.ATTRIBUTE_NOTIFICATION_STYLE,
-                            n.getStyleName());
-                }
-                target.endTag("notification");
-            }
-            target.endTag("notifications");
-            notifications = null;
-        }
+        page.paintContent(target);
 
         if (scrollIntoView != null) {
             target.addAttribute("scrollTo", scrollIntoView);
@@ -570,10 +680,6 @@ public abstract class Root extends AbstractComponentContainer implements
             actionManager.paintActions(null, target);
         }
 
-        if (fragment != null) {
-            target.addAttribute(VRoot.FRAGMENT_VARIABLE, fragment);
-        }
-
         if (isResizeLazy()) {
             target.addAttribute(VRoot.RESIZE_LAZY, true);
         }
@@ -604,23 +710,14 @@ public abstract class Root extends AbstractComponentContainer implements
 
         if (variables.containsKey(VRoot.FRAGMENT_VARIABLE)) {
             String fragment = (String) variables.get(VRoot.FRAGMENT_VARIABLE);
-            setFragment(fragment, true);
+            getPage().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));
+        if (variables.containsKey("height") || variables.containsKey("width")) {
+            getPage().setBrowserWindowSize((Integer) variables.get("width"),
+                    (Integer) variables.get("height"));
         }
+
     }
 
     /*
@@ -801,11 +898,6 @@ public abstract class Root extends AbstractComponentContainer implements
      */
     private Focusable pendingFocus;
 
-    /**
-     * The current URI fragment.
-     */
-    private String fragment;
-
     private boolean resizeLazy = false;
 
     /**
@@ -827,172 +919,6 @@ public abstract class Root extends AbstractComponentContainer implements
     }
 
     /**
-     * Shows a notification message on the middle of the root. The message
-     * automatically disappears ("humanized message").
-     * 
-     * Care should be taken to to avoid XSS vulnerabilities as the caption is
-     * rendered as html.
-     * 
-     * @see #showNotification(Notification)
-     * @see Notification
-     * 
-     * @param caption
-     *            The message
-     */
-    public void showNotification(String caption) {
-        addNotification(new Notification(caption));
-    }
-
-    /**
-     * Shows a notification message the root. The position and behavior of the
-     * message depends on the type, which is one of the basic types defined in
-     * {@link Notification}, for instance Notification.TYPE_WARNING_MESSAGE.
-     * 
-     * Care should be taken to to avoid XSS vulnerabilities as the caption is
-     * rendered as html.
-     * 
-     * @see #showNotification(Notification)
-     * @see Notification
-     * 
-     * @param caption
-     *            The message
-     * @param type
-     *            The message type
-     */
-    public void showNotification(String caption, int type) {
-        addNotification(new Notification(caption, type));
-    }
-
-    /**
-     * Shows a notification consisting of a bigger caption and a smaller
-     * description on the middle of the root. The message automatically
-     * disappears ("humanized message").
-     * 
-     * Care should be taken to to avoid XSS vulnerabilities as the caption and
-     * description are rendered as html.
-     * 
-     * @see #showNotification(Notification)
-     * @see Notification
-     * 
-     * @param caption
-     *            The caption of the message
-     * @param description
-     *            The message description
-     * 
-     */
-    public void showNotification(String caption, String description) {
-        addNotification(new Notification(caption, description));
-    }
-
-    /**
-     * Shows a notification consisting of a bigger caption and a smaller
-     * description. The position and behavior of the message depends on the
-     * type, which is one of the basic types defined in {@link Notification},
-     * for instance Notification.TYPE_WARNING_MESSAGE.
-     * 
-     * Care should be taken to to avoid XSS vulnerabilities as the caption and
-     * description are rendered as html.
-     * 
-     * @see #showNotification(Notification)
-     * @see Notification
-     * 
-     * @param caption
-     *            The caption of the message
-     * @param description
-     *            The message description
-     * @param type
-     *            The message type
-     */
-    public void showNotification(String caption, String description, int type) {
-        addNotification(new Notification(caption, description, type));
-    }
-
-    /**
-     * Shows a notification consisting of a bigger caption and a smaller
-     * description. The position and behavior of the message depends on the
-     * type, which is one of the basic types defined in {@link Notification},
-     * for instance Notification.TYPE_WARNING_MESSAGE.
-     * 
-     * Care should be taken to avoid XSS vulnerabilities if html content is
-     * allowed.
-     * 
-     * @see #showNotification(Notification)
-     * @see Notification
-     * 
-     * @param caption
-     *            The message caption
-     * @param description
-     *            The message description
-     * @param type
-     *            The type of message
-     * @param htmlContentAllowed
-     *            Whether html in the caption and description should be
-     *            displayed as html or as plain text
-     */
-    public void showNotification(String caption, String description, int type,
-            boolean htmlContentAllowed) {
-        addNotification(new Notification(caption, description, type,
-                htmlContentAllowed));
-    }
-
-    /**
-     * Shows a notification message.
-     * 
-     * @see Notification
-     * @see #showNotification(String)
-     * @see #showNotification(String, int)
-     * @see #showNotification(String, String)
-     * @see #showNotification(String, String, int)
-     * 
-     * @param notification
-     *            The notification message to show
-     */
-    public void showNotification(Notification notification) {
-        addNotification(notification);
-    }
-
-    /**
-     * Internal helper method to actually add a notification.
-     * 
-     * @param notification
-     *            the notification to add
-     */
-    private void addNotification(Notification notification) {
-        if (notifications == null) {
-            notifications = new LinkedList<Notification>();
-        }
-        notifications.add(notification);
-        requestRepaint();
-    }
-
-    /**
-     * Executes JavaScript in this root.
-     * 
-     * <p>
-     * This method allows one to inject javascript from the server to client. A
-     * client implementation is not required to implement this functionality,
-     * but currently all web-based clients do implement this.
-     * </p>
-     * 
-     * <p>
-     * Executing javascript this way often leads to cross-browser compatibility
-     * issues and regressions that are hard to resolve. Use of this method
-     * should be avoided and instead it is recommended to create new widgets
-     * with GWT. For more info on creating own, reusable client-side widgets in
-     * Java, read the corresponding chapter in Book of Vaadin.
-     * </p>
-     * 
-     * @param script
-     *            JavaScript snippet that will be executed.
-     * 
-     * @deprecated as of 7.0, use getJavaScript().execute(String) instead
-     */
-    @Deprecated
-    public void executeJavaScript(String script) {
-        getJavaScript().execute(script);
-    }
-
-    /**
      * Scrolls any component between the component and root to a suitable
      * position so the component is visible to the user. The given component
      * must belong to this root.
@@ -1106,10 +1032,7 @@ public abstract class Root extends AbstractComponentContainer implements
      *            the initialization request
      */
     public void doInit(WrappedRequest request) {
-        BrowserDetails browserDetails = request.getBrowserDetails();
-        if (browserDetails != null) {
-            fragment = browserDetails.getUriFragment();
-        }
+        getPage().init(request);
 
         // Call the init overridden by the application developer
         init(request);
@@ -1168,186 +1091,6 @@ public abstract class Root extends AbstractComponentContainer implements
         return currentRoot.get();
     }
 
-    /**
-     * Opens the given resource in this root. The contents of this Root is
-     * replaced by the {@code Resource}.
-     * 
-     * @param resource
-     *            the resource to show in this root
-     */
-    public void open(Resource resource) {
-        synchronized (openList) {
-            if (!openList.contains(resource)) {
-                openList.add(new OpenResource(resource, null, -1, -1,
-                        BORDER_DEFAULT));
-            }
-        }
-        requestRepaint();
-    }
-
-    /* ********************************************************************* */
-
-    /**
-     * Opens the given resource in a window with the given name.
-     * <p>
-     * The supplied {@code windowName} is used as the target name in a
-     * window.open call in the client. This means that special values such as
-     * "_blank", "_self", "_top", "_parent" have special meaning. An empty or
-     * <code>null</code> window name is also a special case.
-     * </p>
-     * <p>
-     * "", null and "_self" as {@code windowName} all causes the resource to be
-     * opened in the current window, replacing any old contents. For
-     * downloadable content you should avoid "_self" as "_self" causes the
-     * client to skip rendering of any other changes as it considers them
-     * irrelevant (the page will be replaced by the resource). This can speed up
-     * the opening of a resource, but it might also put the client side into an
-     * inconsistent state if the window content is not completely replaced e.g.,
-     * if the resource is downloaded instead of displayed in the browser.
-     * </p>
-     * <p>
-     * "_blank" as {@code windowName} causes the resource to always be opened in
-     * a new window or tab (depends on the browser and browser settings).
-     * </p>
-     * <p>
-     * "_top" and "_parent" as {@code windowName} works as specified by the HTML
-     * standard.
-     * </p>
-     * <p>
-     * Any other {@code windowName} will open the resource in a window with that
-     * name, either by opening a new window/tab in the browser or by replacing
-     * the contents of an existing window with that name.
-     * </p>
-     * 
-     * @param resource
-     *            the resource.
-     * @param windowName
-     *            the name of the window.
-     */
-    public void open(Resource resource, String windowName) {
-        synchronized (openList) {
-            if (!openList.contains(resource)) {
-                openList.add(new OpenResource(resource, windowName, -1, -1,
-                        BORDER_DEFAULT));
-            }
-        }
-        requestRepaint();
-    }
-
-    /**
-     * Opens the given resource in a window with the given size, border and
-     * name. For more information on the meaning of {@code windowName}, see
-     * {@link #open(Resource, String)}.
-     * 
-     * @param resource
-     *            the resource.
-     * @param windowName
-     *            the name of the window.
-     * @param width
-     *            the width of the window in pixels
-     * @param height
-     *            the height of the window in pixels
-     * @param border
-     *            the border style of the window. See {@link #BORDER_NONE
-     *            Window.BORDER_* constants}
-     */
-    public void open(Resource resource, String windowName, int width,
-            int height, int border) {
-        synchronized (openList) {
-            if (!openList.contains(resource)) {
-                openList.add(new OpenResource(resource, windowName, width,
-                        height, border));
-            }
-        }
-        requestRepaint();
-    }
-
-    /**
-     * Private class for storing properties related to opening resources.
-     */
-    private class OpenResource implements Serializable {
-
-        /**
-         * The resource to open
-         */
-        private final Resource resource;
-
-        /**
-         * The name of the target window
-         */
-        private final String name;
-
-        /**
-         * The width of the target window
-         */
-        private final int width;
-
-        /**
-         * The height of the target window
-         */
-        private final int height;
-
-        /**
-         * The border style of the target window
-         */
-        private final int border;
-
-        /**
-         * Creates a new open resource.
-         * 
-         * @param resource
-         *            The resource to open
-         * @param name
-         *            The name of the target window
-         * @param width
-         *            The width of the target window
-         * @param height
-         *            The height of the target window
-         * @param border
-         *            The border style of the target window
-         */
-        private OpenResource(Resource resource, String name, int width,
-                int height, int border) {
-            this.resource = resource;
-            this.name = name;
-            this.width = width;
-            this.height = height;
-            this.border = border;
-        }
-
-        /**
-         * Paints the open request. Should be painted inside the window.
-         * 
-         * @param target
-         *            the paint target
-         * @throws PaintException
-         *             if the paint operation fails
-         */
-        private void paintContent(PaintTarget target) throws PaintException {
-            target.startTag("open");
-            target.addAttribute("src", resource);
-            if (name != null && name.length() > 0) {
-                target.addAttribute("name", name);
-            }
-            if (width >= 0) {
-                target.addAttribute("width", width);
-            }
-            if (height >= 0) {
-                target.addAttribute("height", height);
-            }
-            switch (border) {
-            case BORDER_MINIMAL:
-                target.addAttribute("border", "minimal");
-                break;
-            case BORDER_NONE:
-                target.addAttribute("border", "none");
-                break;
-            }
-
-            target.endTag("open");
-        }
-    }
-
     public void setScrollTop(int scrollTop) {
         throw new RuntimeException("Not yet implemented");
     }
@@ -1435,110 +1178,6 @@ public abstract class Root extends AbstractComponentContainer implements
         removeListener(CLICK_EVENT_ID, ClickEvent.class, listener);
     }
 
-    public void addListener(FragmentChangedListener listener) {
-        addListener(FragmentChangedEvent.class, listener,
-                FRAGMENT_CHANGED_METHOD);
-    }
-
-    public void removeListener(FragmentChangedListener listener) {
-        removeListener(FragmentChangedEvent.class, listener,
-                FRAGMENT_CHANGED_METHOD);
-    }
-
-    /**
-     * Sets URI fragment. Optionally fires a {@link FragmentChangedEvent}
-     * 
-     * @param newFragment
-     *            id of the new fragment
-     * @param fireEvent
-     *            true to fire event
-     * @see FragmentChangedEvent
-     * @see FragmentChangedListener
-     */
-    public void setFragment(String newFragment, boolean fireEvents) {
-        if (newFragment == null) {
-            throw new NullPointerException("The fragment may not be null");
-        }
-        if (!newFragment.equals(fragment)) {
-            fragment = newFragment;
-            if (fireEvents) {
-                fireEvent(new FragmentChangedEvent(this, newFragment));
-            }
-            requestRepaint();
-        }
-    }
-
-    /**
-     * Sets URI fragment. This method fires a {@link FragmentChangedEvent}
-     * 
-     * @param newFragment
-     *            id of the new fragment
-     * @see FragmentChangedEvent
-     * @see FragmentChangedListener
-     */
-    public void setFragment(String newFragment) {
-        setFragment(newFragment, true);
-    }
-
-    /**
-     * Gets currently set URI fragment.
-     * <p>
-     * To listen changes in fragment, hook a {@link FragmentChangedListener}.
-     * 
-     * @return the current fragment in browser uri or null if not known
-     */
-    public String getFragment() {
-        return fragment;
-    }
-
-    /**
-     * 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);
-    }
-
-    /**
-     * 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;
-    }
-
     /**
      * Notifies the child components and windows that the root is attached to
      * the application.
@@ -1573,14 +1212,21 @@ public abstract class Root extends AbstractComponentContainer implements
         return dirtyConnectorTracker;
     }
 
-    public JavaScript getJavaScript() {
-        if (javaScript == null) {
-            // Create and attach on first use
-            javaScript = new JavaScript();
-            addExtension(javaScript);
-        }
+    public Page getPage() {
+        return page;
+    }
 
-        return javaScript;
+    /**
+     * Setting the caption of a Root is not supported. To set the title of the
+     * HTML page, use Page.setTitle
+     * 
+     * @deprecated as of 7.0.0, use {@link Page#setTitle(String)}
+     */
+    @Override
+    @Deprecated
+    public void setCaption(String caption) {
+        throw new IllegalStateException(
+                "You can not set the title of a Root. To set the title of the HTML page, use Page.setTitle");
     }
 
 }