Java tutorial
/* * Copyright 2008 Google Inc. * * 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.google.gwt.widgetideas.client; import com.google.gwt.event.logical.shared.ResizeEvent; import com.google.gwt.event.logical.shared.ResizeHandler; import com.google.gwt.event.shared.HandlerRegistration; import com.google.gwt.user.client.DOM; import com.google.gwt.user.client.Timer; import com.google.gwt.user.client.Window; import com.google.gwt.user.client.WindowResizeListener; import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * A collection of {@link ResizableWidget} that periodically checks the outer * dimensions of a widget and redraws it as necessary. Every * {@link ResizableWidgetCollection} uses a timer, so consider the cost when * adding one. * * Typically, a {@link ResizableWidgetCollection} is only needed if you expect * your widgets to resize based on window resizing or other events. Fixed sized * Widgets do not need to be added to a {@link ResizableWidgetCollection} as * they cannot be resized. */ @SuppressWarnings("deprecation") public class ResizableWidgetCollection implements WindowResizeListener, Iterable<ResizableWidget> { /** * Information about a widgets size. */ private static class ResizableWidgetInfo { /** * The current clientHeight. */ private int curHeight = 0; /** * The current clientWidth. */ private int curWidth = 0; /** * Constructor. * * @param widget the widget that will be monitored */ public ResizableWidgetInfo(ResizableWidget widget) { curWidth = DOM.getElementPropertyInt(widget.getElement(), "clientWidth"); curHeight = DOM.getElementPropertyInt(widget.getElement(), "clientHeight"); } /** * Set the new dimensions of the widget if they changed. * * @param width the new width * @param height the new height * @return true if the dimensions have changed */ public boolean setClientSize(int width, int height) { if (width != curWidth || height != curHeight) { this.curWidth = width; this.curHeight = height; return true; } else { return false; } } } /** * The default delay between resize checks in milliseconds. */ private static final int DEFAULT_RESIZE_CHECK_DELAY = 400; /** * A static {@link ResizableWidgetCollection} that can be used in most cases. */ private static ResizableWidgetCollection staticCollection = null; /** * Get the globally accessible {@link ResizableWidgetCollection}. In most * cases, the global collection can be used for all {@link ResizableWidget}s. * * @return the global {@link ResizableWidgetCollection} */ public static ResizableWidgetCollection get() { if (staticCollection == null) { staticCollection = new ResizableWidgetCollection(); } return staticCollection; } /** * The timer used to periodically compare the dimensions of elements to their * old dimensions. */ private Timer resizeCheckTimer = new Timer() { @Override public void run() { // Ignore changes that result from window resize events if (windowHeight != Window.getClientHeight() || windowWidth != Window.getClientWidth()) { windowHeight = Window.getClientHeight(); windowWidth = Window.getClientWidth(); schedule(resizeCheckDelay); return; } // Look for elements that have new dimensions checkWidgetSize(); // Start checking again if (resizeCheckingEnabled) { schedule(resizeCheckDelay); } } }; /** * A hash map of the resizable widgets this collection is checking. */ private Map<ResizableWidget, ResizableWidgetInfo> widgets = new HashMap<ResizableWidget, ResizableWidgetInfo>(); /** * The current window height. */ private int windowHeight = 0; /** * The current window width. */ private int windowWidth = 0; /** * The hook used to remove the window handler. */ private HandlerRegistration windowHandler; /** * The delay between resize checks. */ private int resizeCheckDelay = DEFAULT_RESIZE_CHECK_DELAY; /** * A boolean indicating that resize checking should run. */ private boolean resizeCheckingEnabled; /** * Create a ResizableWidget. */ public ResizableWidgetCollection() { this(DEFAULT_RESIZE_CHECK_DELAY); } /** * Constructor. * * @param resizeCheckingEnabled false to disable resize checking */ public ResizableWidgetCollection(boolean resizeCheckingEnabled) { this(DEFAULT_RESIZE_CHECK_DELAY, resizeCheckingEnabled); } /** * Constructor. * * @param resizeCheckDelay the delay between checks in milliseconds */ public ResizableWidgetCollection(int resizeCheckDelay) { this(resizeCheckDelay, true); } /** * Constructor. */ protected ResizableWidgetCollection(int resizeCheckDelay, boolean resizeCheckingEnabled) { setResizeCheckDelay(resizeCheckDelay); setResizeCheckingEnabled(resizeCheckingEnabled); } /** * Add a resizable widget to the collection. * * @param widget the resizable widget to add */ public void add(ResizableWidget widget) { widgets.put(widget, new ResizableWidgetInfo(widget)); } /** * Check to see if any Widgets have been resized and call their handlers * appropriately. */ public void checkWidgetSize() { for (Map.Entry<ResizableWidget, ResizableWidgetInfo> entry : widgets.entrySet()) { ResizableWidget widget = entry.getKey(); ResizableWidgetInfo info = entry.getValue(); int curWidth = widget.getElement().getPropertyInt("clientWidth"); int curHeight = widget.getElement().getPropertyInt("clientHeight"); // Call the onResize method only if the widget is attached if (info.setClientSize(curWidth, curHeight)) { if (curWidth > 0 && curHeight > 0 && widget.isAttached()) { widget.onResize(curWidth, curHeight); } } } } /** * Get the delay between resize checks in milliseconds. * * @return the resize check delay */ public int getResizeCheckDelay() { return resizeCheckDelay; } /** * Check whether or not resize checking is enabled. * * @return true is resize checking is enabled */ public boolean isResizeCheckingEnabled() { return resizeCheckingEnabled; } public Iterator<ResizableWidget> iterator() { return widgets.keySet().iterator(); } /** * Called when the browser window is resized. * * @param width the width of the window's client area. * @param height the height of the window's client area. */ @Deprecated public void onWindowResized(int width, int height) { checkWidgetSize(); } /** * Remove a {@link ResizableWidget} from the collection. * * @param widget the widget to remove */ public void remove(ResizableWidget widget) { widgets.remove(widget); } /** * Set the delay between resize checks in milliseconds. * * @param resizeCheckDelay the new delay */ public void setResizeCheckDelay(int resizeCheckDelay) { this.resizeCheckDelay = resizeCheckDelay; } /** * Set whether or not resize checking is enabled. If disabled, elements will * still be resized on window events, but the timer will not check their * dimensions periodically. * * @param enabled true to enable the resize checking timer */ public void setResizeCheckingEnabled(boolean enabled) { if (enabled && !resizeCheckingEnabled) { resizeCheckingEnabled = true; if (windowHandler == null) { windowHandler = Window.addResizeHandler(new ResizeHandler() { public void onResize(ResizeEvent event) { onWindowResized(event.getWidth(), event.getHeight()); } }); } resizeCheckTimer.schedule(resizeCheckDelay); } else if (!enabled && resizeCheckingEnabled) { resizeCheckingEnabled = false; if (windowHandler != null) { windowHandler.removeHandler(); windowHandler = null; } resizeCheckTimer.cancel(); } } /** * Inform the {@link ResizableWidgetCollection} that the size of a widget has * changed and already been redrawn. This will prevent the widget from being * redrawn on the next loop. * * @param widget the widget's size that changed */ public void updateWidgetSize(ResizableWidget widget) { if (!widget.isAttached()) { return; } ResizableWidgetInfo info = widgets.get(widget); if (info != null) { int curWidth = widget.getElement().getPropertyInt("clientWidth"); int curHeight = widget.getElement().getPropertyInt("clientHeight"); info.setClientSize(curWidth, curHeight); } } }