import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.Connect.LoadStyle;
import com.vaadin.shared.ui.ui.PageClientRpc;
+import com.vaadin.shared.ui.ui.PageState;
import com.vaadin.shared.ui.ui.ScrollClientRpc;
import com.vaadin.shared.ui.ui.UIClientRpc;
import com.vaadin.shared.ui.ui.UIConstants;
getRpcProxy(UIServerRpc.class).resize(event.getHeight(),
event.getWidth(), Window.getClientWidth(),
Window.getClientHeight());
- if (getState().immediate) {
+ if (getState().immediate || getPageState().hasResizeListeners) {
getConnection().sendPendingVariableChanges();
}
}
return (UIState) super.getState();
}
+ /**
+ * Returns the state of the Page associated with the UI.
+ * <p>
+ * Note that state is considered an internal part of the connector. You
+ * should not rely on the state object outside of the connector who owns it.
+ * If you depend on the state of other connectors you should use their
+ * public API instead of their state object directly. The page state might
+ * not be an independent state object but can be embedded in UI state.
+ * </p>
+ *
+ * @since 7.1
+ * @return state object of the page
+ */
+ public PageState getPageState() {
+ return getState().pageState;
+ }
+
@Override
public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
ComponentConnector oldChild = null;
import com.vaadin.event.EventRouter;
import com.vaadin.shared.ui.BorderStyle;
import com.vaadin.shared.ui.ui.PageClientRpc;
+import com.vaadin.shared.ui.ui.PageState;
import com.vaadin.shared.ui.ui.UIConstants;
+import com.vaadin.shared.ui.ui.UIState;
import com.vaadin.ui.JavaScript;
import com.vaadin.ui.LegacyWindow;
import com.vaadin.ui.Link;
}
}
- private static final Method BROWSWER_RESIZE_METHOD = ReflectTools
+ private static final Method BROWSER_RESIZE_METHOD = ReflectTools
.findMethod(BrowserWindowResizeListener.class,
"browserWindowResized", BrowserWindowResizeEvent.class);
*/
private URI location;
- public Page(UI uI) {
+ private final PageState state;
+
+ public Page(UI uI, PageState state) {
this.uI = uI;
+ this.state = state;
}
private void addListener(Class<?> eventType, Object target, Method method) {
}
/**
- * Adds a new {@link BrowserWindowResizeListener} to this uI. The listener
- * will be notified whenever the browser window within which this uI resides
+ * Adds a new {@link BrowserWindowResizeListener} to this UI. The listener
+ * will be notified whenever the browser window within which this UI resides
* is resized.
+ * <p>
+ * In most cases, the UI should be in lazy resize mode when using browser
+ * window resize listeners. Otherwise, a large number of events can be
+ * received while a resize is being performed. Use
+ * {@link UI#setResizeLazy(boolean)}.
+ * </p>
*
* @param resizeListener
* the listener to add
*
* @see BrowserWindowResizeListener#browserWindowResized(BrowserWindowResizeEvent)
- * @see #setResizeLazy(boolean)
+ * @see UI#setResizeLazy(boolean)
*/
public void addBrowserWindowResizeListener(
BrowserWindowResizeListener resizeListener) {
addListener(BrowserWindowResizeEvent.class, resizeListener,
- BROWSWER_RESIZE_METHOD);
+ BROWSER_RESIZE_METHOD);
+ getState(true).hasResizeListeners = true;
}
/**
public void removeBrowserWindowResizeListener(
BrowserWindowResizeListener resizeListener) {
removeListener(BrowserWindowResizeEvent.class, resizeListener,
- BROWSWER_RESIZE_METHOD);
+ BROWSER_RESIZE_METHOD);
+ getState(true).hasResizeListeners = eventRouter
+ .hasListeners(BrowserWindowResizeEvent.class);
}
/**
uI.getRpcProxy(PageClientRpc.class).reload();
}
+ /**
+ * Returns the page state.
+ * <p>
+ * The page state is transmitted to UIConnector together with
+ * {@link UIState} rather than as an individual entity.
+ * </p>
+ * <p>
+ * The state should be considered an internal detail of Page. Classes
+ * outside of Page should not access it directly but only through public
+ * APIs provided by Page.
+ * </p>
+ *
+ * @since 7.1
+ * @param markAsDirty
+ * true to mark the state as dirty
+ * @return PageState object that can be read in any case and modified if
+ * markAsDirty is true
+ */
+ protected PageState getState(boolean markAsDirty) {
+ if (markAsDirty) {
+ uI.markAsDirty();
+ }
+ return state;
+ }
+
}
/** Identifies the click event */
private ConnectorTracker connectorTracker = new ConnectorTracker(this);
- private Page page = new Page(this);
+ private Page page = new Page(this, getState(false).pageState);
private LoadingIndicatorConfiguration loadingIndicatorConfiguration = new LoadingIndicatorConfigurationImpl(
this);
/**
* 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.
+ * layout sizes are recalculated and resize events are sent to the server.
+ * Speeds up resize operations in slow UIs with the penalty of slightly
+ * decreased usability.
* <p>
* Default value: <code>false</code>
+ * </p>
+ * <p>
+ * When there are active window resize listeners, lazy resize mode should be
+ * used to avoid a large number of events during resize.
+ * </p>
*
* @param resizeLazy
* true to use a delay before recalculating sizes, false to
session.storeInSession(mockService, mockWrappedSession);
ui = new UI() {
- Page page = new Page(this) {
+ Page page = new Page(this, getState(false).pageState) {
@Override
public void init(VaadinRequest request) {
}
--- /dev/null
+/*
+ * Copyright 2000-2013 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.shared.ui.ui;
+
+import java.io.Serializable;
+
+import com.vaadin.server.Page;
+
+/**
+ * The shared state of a {@link Page}.
+ *
+ * Note that at the moment this is not a stand-alone state class but embedded in
+ * {@link UIState}. This might change in the future.
+ *
+ * @since 7.1
+ */
+public class PageState implements Serializable {
+ /**
+ * True if the page has browser window resize listeners.
+ */
+ public boolean hasResizeListeners = false;
+}
\ No newline at end of file
public int maxWidth = 500;
}
+ /**
+ * State related to the {@link Page} class.
+ */
+ public PageState pageState = new PageState();
+
{
primaryStyleName = "v-ui";
// Default is 1 for legacy reasons
projects / vaadin-framework.git / commitdiff