Separate pure client side util methods to a new class (#15553, #15544)

* Deprecated old methods in Util for backwards compatibility

Change-Id: I9de5e6b930d9f2c0268967dc7b1cf465e6310280

client/src/com/vaadin/client/ApplicationConfiguration.java

              * desired locations even if the base URL of the page changes later
              * (e.g. with pushState)
              */
-            serviceUrl = Util.getAbsoluteUrl(serviceUrl);
+            serviceUrl = WidgetUtil.getAbsoluteUrl(serviceUrl);
         }
         // Ensure there's an ending slash (to make appending e.g. UIDL work)
         if (!useServiceUrlPathParam() && !serviceUrl.endsWith("/")) {
             serviceUrl += '/';
         }
 
-        vaadinDirUrl = Util.getAbsoluteUrl(jsoConfiguration
+        vaadinDirUrl = WidgetUtil.getAbsoluteUrl(jsoConfiguration
                 .getConfigString(ApplicationConstants.VAADIN_DIR_URL));
         uiId = jsoConfiguration.getConfigInteger(UIConstants.UI_ID_PARAMETER)
                 .intValue();

client/src/com/vaadin/client/ApplicationConnection.java

 import com.google.gwt.user.client.ui.HasWidgets;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ApplicationConfiguration.ErrorMessage;
+import com.vaadin.client.ApplicationConnection.ApplicationStoppedEvent;
 import com.vaadin.client.ResourceLoader.ResourceLoadEvent;
 import com.vaadin.client.ResourceLoader.ResourceLoadListener;
 import com.vaadin.client.communication.HasJavaScriptConnectorHelper;
                 } catch (NoDataException e) {
                     throw new RuntimeException(
                             "Missing data needed to invoke @DelegateToWidget for "
-                                    + Util.getSimpleName(component), e);
+                                    + WidgetUtil.getSimpleName(component), e);
                 }
             }
 
                             String key = null;
                             if (Profiler.isEnabled()) {
                                 key = "updateFromUIDL for "
-                                        + Util.getSimpleName(legacyConnector);
+                                        + WidgetUtil
+                                                .getSimpleName(legacyConnector);
                                 Profiler.enter(key);
                             }
 
                             Profiler.enter("updateConnectorState inner loop");
                             if (Profiler.isEnabled()) {
                                 Profiler.enter("Decode connector state "
-                                        + Util.getSimpleName(connector));
+                                        + WidgetUtil.getSimpleName(connector));
                             }
 
                             JavaScriptObject jso = states
                                     .getJavaScriptObject(connectorId);
-                            JsonObject stateJson = Util.jso2json(jso);
+                            JsonObject stateJson = WidgetUtil.jso2json(jso);
 
                             if (connector instanceof HasJavaScriptConnectorHelper) {
                                 ((HasJavaScriptConnectorHelper) connector)
 
                             if (Profiler.isEnabled()) {
                                 Profiler.leave("Decode connector state "
-                                        + Util.getSimpleName(connector));
+                                        + WidgetUtil.getSimpleName(connector));
                             }
 
                             Profiler.enter("updateConnectorState create event");
 
                     VConsole.log(" * Performing server to client RPC calls");
 
-                    JsonArray rpcCalls = Util.jso2json(json
+                    JsonArray rpcCalls = WidgetUtil.jso2json(json
                             .getJavaScriptObject("rpc"));
 
                     int rpcLength = rpcCalls.length();
      * @return Connector for focused element or null.
      */
     private ComponentConnector getActiveConnector() {
-        Element focusedElement = Util.getFocusedElement();
+        Element focusedElement = WidgetUtil.getFocusedElement();
         if (focusedElement == null) {
             return null;
         }

client/src/com/vaadin/client/BrowserInfo.java

     public boolean requiresOverflowAutoFix() {
         return (getWebkitVersion() > 0 || getOperaVersion() >= 11
                 || getIEVersion() >= 10 || isFirefox())
-                && Util.getNativeScrollbarSize() > 0;
+                && WidgetUtil.getNativeScrollbarSize() > 0;
     }
 
     /**
      *         otherwise <code>false</code>
      */
     public boolean requiresPositionAbsoluteOverflowAutoFix() {
-        return (getWebkitVersion() > 0) && Util.getNativeScrollbarSize() > 0;
+        return (getWebkitVersion() > 0)
+                && WidgetUtil.getNativeScrollbarSize() > 0;
     }
 
     /**

client/src/com/vaadin/client/JavaScriptConnectorHelper.java

             iface = findWildcardInterface(method);
         }
 
-        JsonArray argumentsArray = Util.jso2json(arguments);
+        JsonArray argumentsArray = WidgetUtil.jso2json(arguments);
         Object[] parameters = new Object[arguments.length()];
         for (int i = 0; i < parameters.length; i++) {
             parameters[i] = argumentsArray.get(i);
     }-*/;
 
     public Object[] decodeRpcParameters(JsonArray parametersJson) {
-        return new Object[] { Util.json2jso(parametersJson) };
+        return new Object[] { WidgetUtil.json2jso(parametersJson) };
     }
 
     public void setTag(int tag) {
         if ("com.vaadin.ui.JavaScript$JavaScriptCallbackRpc".equals(iface)
                 && "call".equals(method)) {
             String callbackName = parametersJson.getString(0);
-            JavaScriptObject arguments = Util.json2jso(parametersJson.get(1));
+            JavaScriptObject arguments = WidgetUtil.json2jso(parametersJson
+                    .get(1));
             invokeCallback(getConnectorWrapper(), callbackName, arguments);
         } else {
-            JavaScriptObject arguments = Util.json2jso(parametersJson);
+            JavaScriptObject arguments = WidgetUtil.json2jso(parametersJson);
             invokeJsRpc(rpcMap, iface, method, arguments);
             // Also invoke wildcard interface
             invokeJsRpc(rpcMap, "", method, arguments);

client/src/com/vaadin/client/LayoutManager.java

                                 if (Profiler.isEnabled()) {
                                     Profiler.enter("ElementResizeListener.onElementResize construct profiler key");
                                     key = "ElementResizeListener.onElementResize for "
-                                            + Util.getSimpleName(listener);
+                                            + WidgetUtil
+                                                    .getSimpleName(listener);
                                     Profiler.leave("ElementResizeListener.onElementResize construct profiler key");
                                     Profiler.enter(key);
                                 }
                             String key = null;
                             if (Profiler.isEnabled()) {
                                 key = "layoutHorizontally() for "
-                                        + Util.getSimpleName(cl);
+                                        + WidgetUtil.getSimpleName(cl);
                                 Profiler.enter(key);
                             }
 
                         try {
                             String key = null;
                             if (Profiler.isEnabled()) {
-                                key = "layout() for " + Util.getSimpleName(rr);
+                                key = "layout() for "
+                                        + WidgetUtil.getSimpleName(rr);
                                 Profiler.enter(key);
                             }
 
                             String key = null;
                             if (Profiler.isEnabled()) {
                                 key = "layoutVertically() for "
-                                        + Util.getSimpleName(cl);
+                                        + WidgetUtil.getSimpleName(cl);
                                 Profiler.enter(key);
                             }
 
                         try {
                             String key = null;
                             if (Profiler.isEnabled()) {
-                                key = "layout() for " + Util.getSimpleName(rr);
+                                key = "layout() for "
+                                        + WidgetUtil.getSimpleName(rr);
                                 Profiler.enter(key);
                             }
 
                 String key = null;
                 if (Profiler.isEnabled()) {
                     key = "layout PostLayoutListener for "
-                            + Util.getSimpleName(connector);
+                            + WidgetUtil.getSimpleName(connector);
                     Profiler.enter(key);
                 }
 

client/src/com/vaadin/client/LayoutManagerIE8.java

          * the containing element. To force a reflow by modifying the magical
          * zoom property.
          */
-        Util.forceIE8Redraw(RootPanel.get().getElement());
+        WidgetUtil.forceIE8Redraw(RootPanel.get().getElement());
         Profiler.leave("LayoutManagerIE8.performBrowserLayoutHacks");
     }
 }

client/src/com/vaadin/client/MeasuredSize.java

         Profiler.leave("Measure borders");
 
         Profiler.enter("Measure height");
-        int requiredHeight = Util.getRequiredHeight(element);
+        int requiredHeight = WidgetUtil.getRequiredHeight(element);
         int marginHeight = sumHeights(margins);
         int oldHeight = height;
         int oldWidth = width;
         Profiler.leave("Measure height");
 
         Profiler.enter("Measure width");
-        int requiredWidth = Util.getRequiredWidth(element);
+        int requiredWidth = WidgetUtil.getRequiredWidth(element);
         int marginWidth = sumWidths(margins);
         if (setOuterWidth(requiredWidth + marginWidth)) {
             debugSizeChange(element, "Width (outer)", oldWidth, width);

client/src/com/vaadin/client/MouseEventDetailsBuilder.java

             Element relativeToElement) {
         MouseEventDetails mouseEventDetails = new MouseEventDetails();
         mouseEventDetails.setType(Event.getTypeInt(evt.getType()));
-        mouseEventDetails.setClientX(Util.getTouchOrMouseClientX(evt));
-        mouseEventDetails.setClientY(Util.getTouchOrMouseClientY(evt));
+        mouseEventDetails.setClientX(WidgetUtil.getTouchOrMouseClientX(evt));
+        mouseEventDetails.setClientY(WidgetUtil.getTouchOrMouseClientY(evt));
         if (evt.getButton() == NativeEvent.BUTTON_LEFT) {
             mouseEventDetails.setButton(MouseButton.LEFT);
         } else if (evt.getButton() == NativeEvent.BUTTON_RIGHT) {

client/src/com/vaadin/client/RenderSpace.java

     public RenderSpace(int width, int height, boolean useNativeScrollbarSize) {
         super(width, height);
         if (useNativeScrollbarSize) {
-            scrollBarSize = Util.getNativeScrollbarSize();
+            scrollBarSize = WidgetUtil.getNativeScrollbarSize();
         }
     }
 

client/src/com/vaadin/client/ResourceLoader.java

      */
     public void loadScript(final String scriptUrl,
             final ResourceLoadListener resourceLoadListener, boolean async) {
-        final String url = Util.getAbsoluteUrl(scriptUrl);
+        final String url = WidgetUtil.getAbsoluteUrl(scriptUrl);
         ResourceLoadEvent event = new ResourceLoadEvent(this, url, false);
         if (loadedResources.contains(url)) {
             if (resourceLoadListener != null) {
      */
     public void preloadResource(String url,
             ResourceLoadListener resourceLoadListener) {
-        url = Util.getAbsoluteUrl(url);
+        url = WidgetUtil.getAbsoluteUrl(url);
         ResourceLoadEvent event = new ResourceLoadEvent(this, url, true);
         if (loadedResources.contains(url) || preloadedResources.contains(url)) {
             // Already loaded or preloaded -> just fire listener
      */
     public void loadStylesheet(final String stylesheetUrl,
             final ResourceLoadListener resourceLoadListener) {
-        final String url = Util.getAbsoluteUrl(stylesheetUrl);
+        final String url = WidgetUtil.getAbsoluteUrl(stylesheetUrl);
         final ResourceLoadEvent event = new ResourceLoadEvent(this, url, false);
         if (loadedResources.contains(url)) {
             if (resourceLoadListener != null) {

client/src/com/vaadin/client/SuperDevMode.java

                         VConsole.error("JSONP compile call failed");
                         // Don't log exception as they are shown as
                         // notifications
-                        VConsole.error(Util.getSimpleName(caught) + ": "
+                        VConsole.error(WidgetUtil.getSimpleName(caught) + ": "
                                 + caught.getMessage());
                         failed();
 

client/src/com/vaadin/client/VCaption.java

         int width = 0;
 
         if (icon != null) {
-            width += Util.getRequiredWidth(icon.getElement());
+            width += WidgetUtil.getRequiredWidth(icon.getElement());
         }
 
         if (captionText != null) {
-            width += Util.getRequiredWidth(captionText);
+            width += WidgetUtil.getRequiredWidth(captionText);
         }
         if (requiredFieldIndicator != null) {
-            width += Util.getRequiredWidth(requiredFieldIndicator);
+            width += WidgetUtil.getRequiredWidth(requiredFieldIndicator);
         }
         if (errorIndicatorElement != null) {
-            width += Util.getRequiredWidth(errorIndicatorElement);
+            width += WidgetUtil.getRequiredWidth(errorIndicatorElement);
         }
 
         return width;
         int width = 0;
 
         if (icon != null) {
-            width += Util.getRequiredWidth(icon.getElement());
+            width += WidgetUtil.getRequiredWidth(icon.getElement());
         }
         if (captionText != null) {
             int textWidth = captionText.getScrollWidth();
                  * In Firefox3 the caption might require more space than the
                  * scrollWidth returns as scrollWidth is rounded down.
                  */
-                int requiredWidth = Util.getRequiredWidth(captionText);
+                int requiredWidth = WidgetUtil.getRequiredWidth(captionText);
                 if (requiredWidth > textWidth) {
                     textWidth = requiredWidth;
                 }
             width += textWidth;
         }
         if (requiredFieldIndicator != null) {
-            width += Util.getRequiredWidth(requiredFieldIndicator);
+            width += WidgetUtil.getRequiredWidth(requiredFieldIndicator);
         }
         if (errorIndicatorElement != null) {
-            width += Util.getRequiredWidth(errorIndicatorElement);
+            width += WidgetUtil.getRequiredWidth(errorIndicatorElement);
         }
 
         return width;
         int h;
 
         if (icon != null) {
-            h = Util.getRequiredHeight(icon.getElement());
+            h = WidgetUtil.getRequiredHeight(icon.getElement());
             if (h > height) {
                 height = h;
             }
         }
 
         if (captionText != null) {
-            h = Util.getRequiredHeight(captionText);
+            h = WidgetUtil.getRequiredHeight(captionText);
             if (h > height) {
                 height = h;
             }
         }
         if (requiredFieldIndicator != null) {
-            h = Util.getRequiredHeight(requiredFieldIndicator);
+            h = WidgetUtil.getRequiredHeight(requiredFieldIndicator);
             if (h > height) {
                 height = h;
             }
         }
         if (errorIndicatorElement != null) {
-            h = Util.getRequiredHeight(errorIndicatorElement);
+            h = WidgetUtil.getRequiredHeight(errorIndicatorElement);
             if (h > height) {
                 height = h;
             }
 
             // DOM.setStyleAttribute(getElement(), "width", maxWidth + "px");
             if (requiredFieldIndicator != null) {
-                availableWidth -= Util.getRequiredWidth(requiredFieldIndicator);
+                availableWidth -= WidgetUtil
+                        .getRequiredWidth(requiredFieldIndicator);
             }
 
             if (errorIndicatorElement != null) {
-                availableWidth -= Util.getRequiredWidth(errorIndicatorElement);
+                availableWidth -= WidgetUtil
+                        .getRequiredWidth(errorIndicatorElement);
             }
 
             if (availableWidth < 0) {
             }
 
             if (icon != null) {
-                int iconRequiredWidth = Util
-                        .getRequiredWidth(icon.getElement());
+                int iconRequiredWidth = WidgetUtil.getRequiredWidth(icon
+                        .getElement());
                 if (availableWidth > iconRequiredWidth) {
                     availableWidth -= iconRequiredWidth;
                 } else {
                 }
             }
             if (captionText != null) {
-                int captionWidth = Util.getRequiredWidth(captionText);
+                int captionWidth = WidgetUtil.getRequiredWidth(captionText);
                 if (availableWidth > captionWidth) {
                     availableWidth -= captionWidth;
 

client/src/com/vaadin/client/VUIDLBrowser.java

             } else {
                 setText("Unknown connector (" + connectorId + ")");
             }
-            dir((JsonObject) Util.jso2json(stateChanges), this);
+            dir((JsonObject) WidgetUtil.jso2json(stateChanges), this);
         }
 
         @Override

client/src/com/vaadin/client/communication/StateChangeEvent.java

 import com.vaadin.client.JsArrayObject;
 import com.vaadin.client.Profiler;
 import com.vaadin.client.ServerConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent.StateChangeHandler;
 import com.vaadin.client.metadata.NoDataException;
 import com.vaadin.client.metadata.Property;
             return true;
         } else if (stateJson != null) {
             // Check whether it's in the json object
-            return isInJson(property, Util.json2jso(stateJson));
+            return isInJson(property, WidgetUtil.json2jso(stateJson));
         } else {
             // Legacy cases
             if (changedProperties != null) {

client/src/com/vaadin/client/componentlocator/LegacyLocatorStrategy.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.Util;
 import com.vaadin.client.VCaption;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.SubPartAware;
 import com.vaadin.client.ui.VCssLayout;
 import com.vaadin.client.ui.VGridLayout;
         // widget to which the path is relative. Otherwise, the current
         // implementation simply interprets the path as if baseElement was
         // null.
-        Widget baseWidget = Util.findWidget(baseElement, null);
+        Widget baseWidget = WidgetUtil.findWidget(baseElement, null);
 
         Widget w = getWidgetFromPath(widgetPath, baseWidget);
-        if (w == null || !Util.isAttachedAndDisplayed(w)) {
+        if (w == null || !WidgetUtil.isAttachedAndDisplayed(w)) {
             return null;
         }
         if (parts.length == 1) {
                 String childIndexString = part.substring("domChild[".length(),
                         part.length() - 1);
 
-                if (Util.findWidget(baseElement, null) instanceof VAbstractOrderedLayout) {
+                if (WidgetUtil.findWidget(baseElement, null) instanceof VAbstractOrderedLayout) {
                     if (element.hasChildNodes()) {
                         Element e = element.getFirstChildElement().cast();
                         String cn = e.getClassName();
         if (basePath == null) {
             return null;
         }
-        String simpleName = Util.getSimpleName(w);
+        String simpleName = WidgetUtil.getSimpleName(w);
 
         /*
          * Check if the parent implements Iterable. At least VPopupView does not
                 return basePath + PARENTCHILD_SEPARATOR + simpleName + "["
                         + pos + "]";
             }
-            String simpleName2 = Util.getSimpleName(child);
+            String simpleName2 = WidgetUtil.getSimpleName(child);
             if (simpleName.equals(simpleName2)) {
                 pos++;
             }
                     // the same type before it
                     int nextIndex = 0;
                     for (Widget child : layout) {
-                        boolean matchingType = nextWidgetClassName.equals(Util
-                                .getSimpleName(child));
+                        boolean matchingType = nextWidgetClassName
+                                .equals(WidgetUtil.getSimpleName(child));
                         if (matchingType && widgetPosition == 0) {
                             // This is the n:th child that we looked for
                             break;
                 while (iterator.hasNext()) {
 
                     Widget child = iterator.next();
-                    String simpleName2 = Util.getSimpleName(child);
+                    String simpleName2 = WidgetUtil.getSimpleName(child);
 
                     if (!widgetClassName.equals(simpleName2)
                             && child instanceof Slot) {
                          * directly checking the stuff inside the slot
                          */
                         child = ((Slot) child).getWidget();
-                        simpleName2 = Util.getSimpleName(child);
+                        simpleName2 = WidgetUtil.getSimpleName(child);
                     }
 
                     if (widgetClassName.equals(simpleName2)) {

client/src/com/vaadin/client/componentlocator/VaadinFinderLocatorStrategy.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.HasComponentsConnector;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.metadata.Property;
 import com.vaadin.client.metadata.TypeDataStore;
 import com.vaadin.client.ui.AbstractConnector;
 
         // If the server-side class name didn't match, fall back to testing for
         // the explicit widget name
-        String widget = Util.getSimpleName(connector.getWidget());
+        String widget = WidgetUtil.getSimpleName(connector.getWidget());
         return widgetName.equals(widget)
                 || widgetName.equals(widget + ".class");
 

client/src/com/vaadin/client/connectors/AbstractRendererConnector.java

 package com.vaadin.client.connectors;
 
 import com.vaadin.client.ServerConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.JsonDecoder;
 import com.vaadin.client.extensions.AbstractExtensionConnector;
 import com.vaadin.client.metadata.NoDataException;
         if (presentationType == null) {
             throw new IllegalStateException(
                     "No presentation type found for "
-                            + Util.getSimpleName(this)
+                            + WidgetUtil.getSimpleName(this)
                             + ". This may be caused by some unspecified problem in widgetset compilation.");
         }
     }
         } catch (NoDataException e) {
             throw new IllegalStateException(
                     "Default implementation of createRenderer() does not work for "
-                            + Util.getSimpleName(this)
+                            + WidgetUtil.getSimpleName(this)
                             + ". This might be caused by explicitely using "
                             + "super.createRenderer() or some unspecified "
                             + "problem with the widgetset compilation.", e);

client/src/com/vaadin/client/debug/internal/AnalyzeLayoutsPanel.java

 import com.vaadin.client.ConnectorMap;
 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.SimpleTree;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ValueMap;
 
 /**
             final ServerConnector parent = connector.getParent();
             final String parentId = parent.getConnectorId();
 
-            final Label errorDetails = new Label(Util.getSimpleName(connector)
-                    + "[" + connector.getConnectorId() + "]" + " inside "
-                    + Util.getSimpleName(parent));
+            final Label errorDetails = new Label(
+                    WidgetUtil.getSimpleName(connector) + "["
+                            + connector.getConnectorId() + "]" + " inside "
+                            + WidgetUtil.getSimpleName(parent));
 
             if (parent instanceof ComponentConnector) {
                 final ComponentConnector parentConnector = (ComponentConnector) parent;
         Highlight.show(connector);
 
         final SimpleTree errorNode = new SimpleTree(
-                Util.getSimpleName(connector) + " id: " + pid);
+                WidgetUtil.getSimpleName(connector) + " id: " + pid);
         errorNode.addDomHandler(new MouseOverHandler() {
             @Override
             public void onMouseOver(MouseOverEvent event) {

client/src/com/vaadin/client/debug/internal/ConnectorInfoPanel.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.JsArrayObject;
 import com.vaadin.client.ServerConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.metadata.NoDataException;
 import com.vaadin.client.metadata.Property;
         ignoreProperties.add("id");
 
         String html = getRowHTML("Id", connector.getConnectorId());
-        html += getRowHTML("Connector", Util.getSimpleName(connector));
+        html += getRowHTML("Connector", WidgetUtil.getSimpleName(connector));
 
         if (connector instanceof ComponentConnector) {
             ComponentConnector component = (ComponentConnector) connector;
             AbstractComponentState componentState = component.getState();
 
             html += getRowHTML("Widget",
-                    Util.getSimpleName(component.getWidget()));
+                    WidgetUtil.getSimpleName(component.getWidget()));
             html += getRowHTML("Caption", componentState.caption);
             html += getRowHTML("Description", componentState.description);
             html += getRowHTML("Width", componentState.width + " (actual: "
         return "<div class=\"" + VDebugWindow.STYLENAME
                 + "-row\"><span class=\"caption\">" + caption
                 + "</span><span class=\"value\">"
-                + Util.escapeHTML(String.valueOf(value)) + "</span></div>";
+                + WidgetUtil.escapeHTML(String.valueOf(value))
+                + "</span></div>";
     }
 
     /**

client/src/com/vaadin/client/debug/internal/HierarchySection.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.Util;
 import com.vaadin.client.ValueMap;
+import com.vaadin.client.WidgetUtil;
 
 /**
  * Provides functionality for examining the UI component hierarchy.
             }
             if (event.getTypeInt() == Event.ONMOUSEMOVE) {
                 Highlight.hideAll();
-                Element eventTarget = Util.getElementFromPoint(event
+                Element eventTarget = WidgetUtil.getElementFromPoint(event
                         .getNativeEvent().getClientX(), event.getNativeEvent()
                         .getClientY());
                 if (VDebugWindow.get().getElement().isOrHasChild(eventTarget)) {
                 event.consume();
                 event.getNativeEvent().stopPropagation();
                 stopFind();
-                Element eventTarget = Util.getElementFromPoint(event
+                Element eventTarget = WidgetUtil.getElementFromPoint(event
                         .getNativeEvent().getClientX(), event.getNativeEvent()
                         .getClientY());
                 for (ApplicationConnection a : ApplicationConfiguration

client/src/com/vaadin/client/debug/internal/TestBenchSection.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.Util;
 import com.vaadin.client.ValueMap;
+import com.vaadin.client.WidgetUtil;
 
 /**
  * Provides functionality for picking selectors for Vaadin TestBench.
 
             String html = "<div class=\"" + VDebugWindow.STYLENAME
                     + "-selector\"><span class=\"tb-selector\">"
-                    + Util.escapeHTML(path.getElementQuery()) + "</span></div>";
+                    + WidgetUtil.escapeHTML(path.getElementQuery())
+                    + "</span></div>";
             setHTML(html);
 
             addMouseOverHandler(this);
             }
             if (event.getTypeInt() == Event.ONMOUSEMOVE
                     || event.getTypeInt() == Event.ONCLICK) {
-                Element eventTarget = Util.getElementFromPoint(event
+                Element eventTarget = WidgetUtil.getElementFromPoint(event
                         .getNativeEvent().getClientX(), event.getNativeEvent()
                         .getClientY());
                 if (VDebugWindow.get().getElement().isOrHasChild(eventTarget)) {
                 // make sure that not finding the highlight element only
                 Highlight.hideAll();
 
-                eventTarget = Util.getElementFromPoint(event.getNativeEvent()
-                        .getClientX(), event.getNativeEvent().getClientY());
+                eventTarget = WidgetUtil.getElementFromPoint(event
+                        .getNativeEvent().getClientX(), event.getNativeEvent()
+                        .getClientY());
                 ComponentConnector connector = findConnector(eventTarget);
 
                 if (event.getTypeInt() == Event.ONMOUSEMOVE) {

client/src/com/vaadin/client/extensions/ResponsiveConnector.java

 
     /**
      * Forces IE8 to reinterpret CSS rules.
-     * {@link com.vaadin.client.Util#forceIE8Redraw(com.google.gwt.dom.client.Element)}
+     * {@link com.vaadin.client.WidgetUtil#forceIE8Redraw(com.google.gwt.dom.client.Element)}
      * doesn't work in this case.
      * 
      * @param element

client/src/com/vaadin/client/extensions/javascriptmanager/JavaScriptManagerConnector.java

 import com.google.gwt.core.client.JavaScriptObject;
 import com.google.gwt.core.client.JsArray;
 import com.vaadin.client.ServerConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.JavaScriptMethodInvocation;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.extensions.AbstractExtensionConnector;
     }-*/;
 
     public void sendRpc(String name, JsArray<JavaScriptObject> arguments) {
-        Object[] parameters = new Object[] { name, Util.jso2json(arguments) };
+        Object[] parameters = new Object[] { name,
+                WidgetUtil.jso2json(arguments) };
 
         /*
          * Must invoke manually as the RPC interface can't be used in GWT

client/src/com/vaadin/client/renderers/ClickableRenderer.java

 import com.google.gwt.event.shared.HandlerManager;
 import com.google.gwt.user.client.ui.Widget;
 import com.google.web.bindery.event.shared.HandlerRegistration;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.widget.escalator.Cell;
 import com.vaadin.client.widget.escalator.RowContainer;
 import com.vaadin.client.widget.grid.CellReference;
          * <strong>Note:</strong> This method may not work reliably if the grid
          * in question is wrapped in a {@link Composite} <em>unless</em> the
          * element is inside another widget that is a child of the wrapped grid;
-         * please refer to the note in {@link Util#findWidget(Element, Class)
-         * Util.findWidget} for details.
+         * please refer to the note in
+         * {@link WidgetUtil#findWidget(Element, Class) Util.findWidget} for
+         * details.
          * 
          * @param e
          *            the element whose parent grid to find
          * @return the parent grid or null if none found.
          */
         private static Grid<?> findClosestParentGrid(Element e) {
-            Widget w = Util.findWidget(e, null);
+            Widget w = WidgetUtil.findWidget(e, null);
 
             while (w != null && !(w instanceof Grid)) {
                 w = w.getParent();

client/src/com/vaadin/client/renderers/WidgetRenderer.java

 
 import com.google.gwt.dom.client.TableCellElement;
 import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.widget.grid.RendererCellReference;
 
 /**
      */
     protected static <W extends Widget> W getWidget(TableCellElement e,
             Class<W> klass) {
-        W w = Util.findWidget(e.getFirstChildElement(), klass);
+        W w = WidgetUtil.findWidget(e.getFirstChildElement(), klass);
         assert w == null || w.getElement() == e.getFirstChildElement() : "Widget not found inside cell";
         return w;
     }

client/src/com/vaadin/client/ui/AbstractClickEventHandler.java

 import com.google.gwt.user.client.Event.NativePreviewEvent;
 import com.google.gwt.user.client.Event.NativePreviewHandler;
 import com.vaadin.client.ComponentConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 
 public abstract class AbstractClickEventHandler implements MouseDownHandler,
 
                 // Event's reported target not always correct if event
                 // capture is in use
-                Element elementUnderMouse = Util.getElementUnderMouse(event
-                        .getNativeEvent());
+                Element elementUnderMouse = WidgetUtil
+                        .getElementUnderMouse(event.getNativeEvent());
                 if (lastMouseDownTarget != null
                         && elementUnderMouse == lastMouseDownTarget) {
                     mouseUpPreviewMatched = true;
          * When getting a mousedown event, we must detect where the
          * corresponding mouseup event if it's on a different part of the page.
          */
-        lastMouseDownTarget = Util.getElementUnderMouse(event.getNativeEvent());
+        lastMouseDownTarget = WidgetUtil.getElementUnderMouse(event
+                .getNativeEvent());
         mouseUpPreviewMatched = false;
         mouseUpEventPreviewRegistration = Event
                 .addNativePreviewHandler(mouseUpPreviewHandler);
         if (hasEventListener()
                 && mouseUpPreviewMatched
                 && lastMouseDownTarget != null
-                && Util.getElementUnderMouse(event.getNativeEvent()) == lastMouseDownTarget
+                && WidgetUtil.getElementUnderMouse(event.getNativeEvent()) == lastMouseDownTarget
                 && shouldFireEvent(event)) {
             // "Click" with left, right or middle button
             fireClick(event.getNativeEvent());

client/src/com/vaadin/client/ui/AbstractComponentConnector.java

 import com.vaadin.client.UIDL;
 import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.metadata.NoDataException;
 import com.vaadin.client.metadata.Type;
         } catch (NoDataException e) {
             throw new IllegalStateException(
                     "Default implementation of createWidget() does not work for "
-                            + Util.getSimpleName(this)
+                            + WidgetUtil.getSimpleName(this)
                             + ". This might be caused by explicitely using "
                             + "super.createWidget() or some unspecified "
                             + "problem with the widgetset compilation.", e);
     public Widget getWidget() {
         if (widget == null) {
             Profiler.enter("AbstractComponentConnector.createWidget for "
-                    + Util.getSimpleName(this));
+                    + WidgetUtil.getSimpleName(this));
             widget = createWidget();
             Profiler.leave("AbstractComponentConnector.createWidget for "
-                    + Util.getSimpleName(this));
+                    + WidgetUtil.getSimpleName(this));
         }
 
         return widget;

client/src/com/vaadin/client/ui/AbstractConnector.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.RpcProxy;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.communication.StateChangeEvent.StateChangeHandler;
 
         addStateChangeHandler(this);
         if (Profiler.isEnabled()) {
-            Profiler.enter("AbstractConnector.init " + Util.getSimpleName(this));
+            Profiler.enter("AbstractConnector.init "
+                    + WidgetUtil.getSimpleName(this));
         }
         init();
         if (Profiler.isEnabled()) {
-            Profiler.leave("AbstractConnector.init " + Util.getSimpleName(this));
+            Profiler.leave("AbstractConnector.init "
+                    + WidgetUtil.getSimpleName(this));
         }
         Profiler.leave("AbstractConnector.doInit");
     }
     public void fireEvent(GwtEvent<?> event) {
         String profilerKey = null;
         if (Profiler.isEnabled()) {
-            profilerKey = "Fire " + Util.getSimpleName(event) + " for "
-                    + Util.getSimpleName(this);
+            profilerKey = "Fire " + WidgetUtil.getSimpleName(event) + " for "
+                    + WidgetUtil.getSimpleName(this);
             Profiler.enter(profilerKey);
         }
         if (handlerManager != null) {
         } catch (NoDataException e) {
             throw new IllegalStateException(
                     "There is no information about the state for "
-                            + Util.getSimpleName(this)
+                            + WidgetUtil.getSimpleName(this)
                             + ". Did you remember to compile the right widgetset?",
                     e);
         }
         } catch (NoDataException e) {
             throw new IllegalStateException(
                     "There is no information about the state for "
-                            + Util.getSimpleName(connector)
+                            + WidgetUtil.getSimpleName(connector)
                             + ". Did you remember to compile the right widgetset?",
                     e);
         }

client/src/com/vaadin/client/ui/MediaBaseConnector.java

  */
 package com.vaadin.client.ui;
 
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.shared.communication.URLReference;
 import com.vaadin.shared.ui.AbstractMediaState;
         if (altText == null || "".equals(altText)) {
             altText = getDefaultAltHtml();
         } else if (!getState().htmlContentAllowed) {
-            altText = Util.escapeHTML(altText);
+            altText = WidgetUtil.escapeHTML(altText);
         }
         getWidget().setAltText(altText);
     }

client/src/com/vaadin/client/ui/VAbstractSplitPanel.java

 import com.vaadin.client.ConnectorMap;
 import com.vaadin.client.LayoutManager;
 import com.vaadin.client.StyleConstants;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.ui.TouchScrollDelegate.TouchScrollHandler;
 import com.vaadin.client.ui.VAbstractSplitPanel.SplitterMoveHandler.SplitterMoveEvent;
             break;
         }
         // Only fire click event listeners if the splitter isn't moved
-        if (Util.isTouchEvent(event) || !resized) {
+        if (WidgetUtil.isTouchEvent(event) || !resized) {
             super.onBrowserEvent(event);
         } else if (DOM.eventGetType(event) == Event.ONMOUSEUP) {
             // Reset the resized flag after a mouseup has occured so the next
             DOM.setCapture(getElement());
             origX = DOM.getElementPropertyInt(splitter, "offsetLeft");
             origY = DOM.getElementPropertyInt(splitter, "offsetTop");
-            origMouseX = Util.getTouchOrMouseClientX(event);
-            origMouseY = Util.getTouchOrMouseClientY(event);
+            origMouseX = WidgetUtil.getTouchOrMouseClientX(event);
+            origMouseY = WidgetUtil.getTouchOrMouseClientY(event);
             event.stopPropagation();
             event.preventDefault();
         }
     public void onMouseMove(Event event) {
         switch (orientation) {
         case HORIZONTAL:
-            final int x = Util.getTouchOrMouseClientX(event);
+            final int x = WidgetUtil.getTouchOrMouseClientX(event);
             onHorizontalMouseMove(x);
             break;
         case VERTICAL:
         default:
-            final int y = Util.getTouchOrMouseClientY(event);
+            final int y = WidgetUtil.getTouchOrMouseClientY(event);
             onVerticalMouseMove(y);
             break;
         }
         DOM.releaseCapture(getElement());
         hideDraggingCurtain();
         resizing = false;
-        if (!Util.isTouchEvent(event)) {
+        if (!WidgetUtil.isTouchEvent(event)) {
             onMouseMove(event);
         }
         fireEvent(new SplitterMoveEvent(this));

client/src/com/vaadin/client/ui/VAccordion.java

 import com.google.gwt.user.client.ui.ComplexPanel;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ComponentConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VCaption;
 import com.vaadin.client.ui.TouchScrollDelegate.TouchScrollHandler;
 import com.vaadin.shared.ComponentConstants;
             }
 
             int captionWidth = caption.getRequiredWidth();
-            int padding = Util.measureHorizontalPaddingAndBorder(
+            int padding = WidgetUtil.measureHorizontalPaddingAndBorder(
                     caption.getElement(), 18);
             return captionWidth + padding;
         }

client/src/com/vaadin/client/ui/VButton.java

 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 public class VButton extends FocusWidget implements ClickHandler {
 
         // Set (x,y) client coordinates to the middle of the button
         int x = getElement().getAbsoluteLeft() - getElement().getScrollLeft()
                 - getElement().getOwnerDocument().getScrollLeft()
-                + Util.getRequiredWidth(getElement()) / 2;
+                + WidgetUtil.getRequiredWidth(getElement()) / 2;
         int y = getElement().getAbsoluteTop() - getElement().getScrollTop()
                 - getElement().getOwnerDocument().getScrollTop()
-                + Util.getRequiredHeight(getElement()) / 2;
+                + WidgetUtil.getRequiredHeight(getElement()) / 2;
         NativeEvent evt = Document.get().createClickEvent(1, 0, 0, x, y, false,
                 false, false, false);
         getElement().dispatchEvent(evt);

client/src/com/vaadin/client/ui/VCalendarPanel.java

 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.DateTimeService;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.shared.ui.datefield.Resolution;
 import com.vaadin.shared.util.SharedUtil;
             return SUBPART_PREV_YEAR;
         } else if (contains(days, subElement)) {
             // Day, find out which dayOfMonth and use that as the identifier
-            Day day = Util.findWidget(subElement, Day.class);
+            Day day = WidgetUtil.findWidget(subElement, Day.class);
             if (day != null) {
                 Date date = day.getDate();
                 int id = date.getDate();

client/src/com/vaadin/client/ui/VContextMenu.java

 import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.impl.FocusImpl;
 import com.vaadin.client.Focusable;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 public class VContextMenu extends VOverlay implements SubPartAware {
 
         addCloseHandler(new CloseHandler<PopupPanel>() {
             @Override
             public void onClose(CloseEvent<PopupPanel> event) {
-                Element currentFocus = Util.getFocusedElement();
+                Element currentFocus = WidgetUtil.getFocusedElement();
                 if (focusedElement != null
                         && (currentFocus == null
                                 || menu.getElement().isOrHasChild(currentFocus) || RootPanel
         }
 
         // Attach onload listeners to all images
-        Util.sinkOnloadForImages(menu.getElement());
+        WidgetUtil.sinkOnloadForImages(menu.getElement());
 
         // Store the currently focused element, which will be re-focused when
         // context menu is closed
-        focusedElement = Util.getFocusedElement();
+        focusedElement = WidgetUtil.getFocusedElement();
 
         // reset height (if it has been previously set explicitly)
         setHeight("");

client/src/com/vaadin/client/ui/VCustomLayout.java

 import com.vaadin.client.Util;
 import com.vaadin.client.VCaption;
 import com.vaadin.client.VCaptionWrapper;
+import com.vaadin.client.WidgetUtil;
 
 /**
  * Custom Layout implements complex layout defined with HTML template.
 
         // TODO prefix img src:s here with a regeps, cannot work further with IE
 
-        String relImgPrefix = Util.escapeAttribute(themeUri + "/layouts/");
+        String relImgPrefix = WidgetUtil
+                .escapeAttribute(themeUri + "/layouts/");
 
         // prefix all relative image elements to point to theme dir with a
         // regexp search

client/src/com/vaadin/client/ui/VEmbedded.java

 import com.vaadin.client.UIDL;
 import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.embedded.EmbeddedConstants;
 
 public class VEmbedded extends HTML {
          */
         if (uidl.hasAttribute("classid")) {
             html.append("classid=\""
-                    + Util.escapeAttribute(uidl.getStringAttribute("classid"))
-                    + "\" ");
+                    + WidgetUtil.escapeAttribute(uidl
+                            .getStringAttribute("classid")) + "\" ");
         } else {
             html.append("classid=\"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\" ");
         }
          */
         if (uidl.hasAttribute("codebase")) {
             html.append("codebase=\""
-                    + Util.escapeAttribute(uidl.getStringAttribute("codebase"))
-                    + "\" ");
+                    + WidgetUtil.escapeAttribute(uidl
+                            .getStringAttribute("codebase")) + "\" ");
         } else {
             html.append("codebase=\"http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0\" ");
         }
         String width = paintable.getState().width;
 
         // Add width and height
-        html.append("width=\"" + Util.escapeAttribute(width) + "\" ");
-        html.append("height=\"" + Util.escapeAttribute(height) + "\" ");
+        html.append("width=\"" + WidgetUtil.escapeAttribute(width) + "\" ");
+        html.append("height=\"" + WidgetUtil.escapeAttribute(height) + "\" ");
         html.append("type=\"application/x-shockwave-flash\" ");
 
         // Codetype
         if (uidl.hasAttribute("codetype")) {
             html.append("codetype=\""
-                    + Util.escapeAttribute(uidl.getStringAttribute("codetype"))
-                    + "\" ");
+                    + WidgetUtil.escapeAttribute(uidl
+                            .getStringAttribute("codetype")) + "\" ");
         }
 
         // Standby
         if (uidl.hasAttribute("standby")) {
             html.append("standby=\""
-                    + Util.escapeAttribute(uidl.getStringAttribute("standby"))
-                    + "\" ");
+                    + WidgetUtil.escapeAttribute(uidl
+                            .getStringAttribute("standby")) + "\" ");
         }
 
         // Archive
         if (uidl.hasAttribute("archive")) {
             html.append("archive=\""
-                    + Util.escapeAttribute(uidl.getStringAttribute("archive"))
-                    + "\" ");
+                    + WidgetUtil.escapeAttribute(uidl
+                            .getStringAttribute("archive")) + "\" ");
         }
 
         // End object tag
         // Add parameters to OBJECT
         for (String name : parameters.keySet()) {
             html.append("<param ");
-            html.append("name=\"" + Util.escapeAttribute(name) + "\" ");
-            html.append("value=\"" + Util.escapeAttribute(parameters.get(name))
-                    + "\" ");
+            html.append("name=\"" + WidgetUtil.escapeAttribute(name) + "\" ");
+            html.append("value=\""
+                    + WidgetUtil.escapeAttribute(parameters.get(name)) + "\" ");
             html.append("/>");
         }
 
         // Build inner EMBED tag
         html.append("<embed ");
-        html.append("src=\"" + Util.escapeAttribute(getSrc(uidl, client))
+        html.append("src=\"" + WidgetUtil.escapeAttribute(getSrc(uidl, client))
                 + "\" ");
-        html.append("width=\"" + Util.escapeAttribute(width) + "\" ");
-        html.append("height=\"" + Util.escapeAttribute(height) + "\" ");
+        html.append("width=\"" + WidgetUtil.escapeAttribute(width) + "\" ");
+        html.append("height=\"" + WidgetUtil.escapeAttribute(height) + "\" ");
         html.append("type=\"application/x-shockwave-flash\" ");
 
         // Add the parameters to the Embed
         for (String name : parameters.keySet()) {
-            html.append(Util.escapeAttribute(name));
+            html.append(WidgetUtil.escapeAttribute(name));
             html.append("=");
-            html.append("\"" + Util.escapeAttribute(parameters.get(name))
+            html.append("\"" + WidgetUtil.escapeAttribute(parameters.get(name))
                     + "\"");
         }
 

client/src/com/vaadin/client/ui/VFilterSelect.java

 import com.vaadin.client.ConnectorMap;
 import com.vaadin.client.Focusable;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.aria.AriaHelper;
 import com.vaadin.client.ui.aria.HandlesAriaCaption;
 import com.vaadin.client.ui.aria.HandlesAriaInvalid;
                 // options and are not collapsed (#7506)
                 content = " ";
             } else {
-                content = Util.escapeHTML(caption);
+                content = WidgetUtil.escapeHTML(caption);
             }
             sb.append("<span>" + content + "</span>");
             return sb.toString();
             final int naturalMenuWidth = menuFirstChild.getOffsetWidth();
 
             if (popupOuterPadding == -1) {
-                popupOuterPadding = Util.measureHorizontalPaddingAndBorder(
-                        getElement(), 2);
+                popupOuterPadding = WidgetUtil
+                        .measureHorizontalPaddingAndBorder(getElement(), 2);
             }
 
             if (naturalMenuWidth < desiredWidth) {
                 menu.setHeight(menuHeight + "px");
 
                 final int naturalMenuWidthPlusScrollBar = naturalMenuWidth
-                        + Util.getNativeScrollbarSize();
+                        + WidgetUtil.getNativeScrollbarSize();
                 if (offsetWidth < naturalMenuWidthPlusScrollBar) {
                     menu.setWidth(naturalMenuWidthPlusScrollBar + "px");
                 }
                 final MenuItem mi = new MenuItem(s.getDisplayString(), true, s);
                 Roles.getListitemRole().set(mi.getElement());
 
-                Util.sinkOnloadForImages(mi.getElement());
+                WidgetUtil.sinkOnloadForImages(mi.getElement());
 
                 this.addItem(mi);
                 if (s == currentSuggestion) {
                  * the end and the focus to the start. This makes Firefox work
                  * the same way as other browsers (#13477)
                  */
-                Util.setSelectionRange(getElement(), pos, length, "backward");
+                WidgetUtil.setSelectionRange(getElement(), pos, length,
+                        "backward");
 
             } else {
                 /*
     }
 
     private void forceReflow() {
-        Util.setStyleTemporarily(tb.getElement(), "zoom", "1");
+        WidgetUtil.setStyleTemporarily(tb.getElement(), "zoom", "1");
     }
 
     /**
         int availableHeight = 0;
         availableHeight = getOffsetHeight();
 
-        int iconHeight = Util.getRequiredHeight(selectedItemIcon);
+        int iconHeight = WidgetUtil.getRequiredHeight(selectedItemIcon);
         int marginTop = (availableHeight - iconHeight) / 2;
         selectedItemIcon.getElement().getStyle()
                 .setMarginTop(marginTop, Unit.PX);
      */
     public void updateSuggestionPopupMinWidth() {
         // used only to calculate minimum width
-        String captions = Util.escapeHTML(inputPrompt);
+        String captions = WidgetUtil.escapeHTML(inputPrompt);
 
         for (FilterSelectSuggestion suggestion : currentSuggestions) {
             // Collect captions so we can calculate minimum width for
             if (captions.length() > 0) {
                 captions += "|";
             }
-            captions += Util.escapeHTML(suggestion.getReplacementString());
+            captions += WidgetUtil
+                    .escapeHTML(suggestion.getReplacementString());
         }
 
         // Calculate minimum textarea width
              */
             preventNextBlurEventInIE = false;
 
-            Element focusedElement = Util.getIEFocusedElement();
+            Element focusedElement = WidgetUtil.getFocusedElement();
             if (getElement().isOrHasChild(focusedElement)
                     || suggestionPopup.getElement()
                             .isOrHasChild(focusedElement)) {
              * when the popup is used to view longer items than the text box is
              * wide.
              */
-            int w = Util.getRequiredWidth(this);
+            int w = WidgetUtil.getRequiredWidth(this);
 
             if ((!initDone || currentPage + 1 < 0)
                     && suggestionPopupMinWidth > w) {
 
                 // Use util.getRequiredWidth instead of getOffsetWidth here
 
-                int iconWidth = selectedItemIcon == null ? 0 : Util
+                int iconWidth = selectedItemIcon == null ? 0 : WidgetUtil
                         .getRequiredWidth(selectedItemIcon);
-                int buttonWidth = popupOpener == null ? 0 : Util
+                int buttonWidth = popupOpener == null ? 0 : WidgetUtil
                         .getRequiredWidth(popupOpener);
 
                 /*

client/src/com/vaadin/client/ui/VFlash.java

 import java.util.Map;
 
 import com.google.gwt.user.client.ui.HTML;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 public class VFlash extends HTML {
 
          * this by setting his own classid.
          */
         if (classId != null) {
-            html.append("classid=\"" + Util.escapeAttribute(classId) + "\" ");
+            html.append("classid=\"" + WidgetUtil.escapeAttribute(classId)
+                    + "\" ");
         } else {
             html.append("classid=\"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\" ");
         }
          * codebase
          */
         if (codebase != null) {
-            html.append("codebase=\"" + Util.escapeAttribute(codebase) + "\" ");
+            html.append("codebase=\"" + WidgetUtil.escapeAttribute(codebase)
+                    + "\" ");
         } else {
             html.append("codebase=\"http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0\" ");
         }
 
         // Add width and height
-        html.append("width=\"" + Util.escapeAttribute(width) + "\" ");
-        html.append("height=\"" + Util.escapeAttribute(height) + "\" ");
+        html.append("width=\"" + WidgetUtil.escapeAttribute(width) + "\" ");
+        html.append("height=\"" + WidgetUtil.escapeAttribute(height) + "\" ");
         html.append("type=\"application/x-shockwave-flash\" ");
 
         // Codetype
         if (codetype != null) {
-            html.append("codetype=\"" + Util.escapeAttribute(codetype) + "\" ");
+            html.append("codetype=\"" + WidgetUtil.escapeAttribute(codetype)
+                    + "\" ");
         }
 
         // Standby
         if (standby != null) {
-            html.append("standby=\"" + Util.escapeAttribute(standby) + "\" ");
+            html.append("standby=\"" + WidgetUtil.escapeAttribute(standby)
+                    + "\" ");
         }
 
         // Archive
         if (archive != null) {
-            html.append("archive=\"" + Util.escapeAttribute(archive) + "\" ");
+            html.append("archive=\"" + WidgetUtil.escapeAttribute(archive)
+                    + "\" ");
         }
 
         // End object tag
         // Add parameters to OBJECT
         for (String name : embedParams.keySet()) {
             html.append("<param ");
-            html.append("name=\"" + Util.escapeAttribute(name) + "\" ");
+            html.append("name=\"" + WidgetUtil.escapeAttribute(name) + "\" ");
             html.append("value=\""
-                    + Util.escapeAttribute(embedParams.get(name)) + "\" ");
+                    + WidgetUtil.escapeAttribute(embedParams.get(name)) + "\" ");
             html.append("/>");
         }
 
         // Build inner EMBED tag
         html.append("<embed ");
-        html.append("src=\"" + Util.escapeAttribute(source) + "\" ");
-        html.append("width=\"" + Util.escapeAttribute(width) + "\" ");
-        html.append("height=\"" + Util.escapeAttribute(height) + "\" ");
+        html.append("src=\"" + WidgetUtil.escapeAttribute(source) + "\" ");
+        html.append("width=\"" + WidgetUtil.escapeAttribute(width) + "\" ");
+        html.append("height=\"" + WidgetUtil.escapeAttribute(height) + "\" ");
         html.append("type=\"application/x-shockwave-flash\" ");
 
         // Add the parameters to the Embed
         for (String name : embedParams.keySet()) {
-            html.append(Util.escapeAttribute(name));
+            html.append(WidgetUtil.escapeAttribute(name));
             html.append("=");
-            html.append("\"" + Util.escapeAttribute(embedParams.get(name))
-                    + "\"");
+            html.append("\""
+                    + WidgetUtil.escapeAttribute(embedParams.get(name)) + "\"");
         }
 
         // End embed tag

client/src/com/vaadin/client/ui/VLabel.java

 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.Util;
 import com.vaadin.client.VTooltip;
+import com.vaadin.client.WidgetUtil;
 
 public class VLabel extends HTML {
 
         if (BrowserInfo.get().isIE8()) {
             // #3983 - IE8 incorrectly replaces \n with <br> so we do the
             // escaping manually and set as HTML
-            super.setHTML(Util.escapeHTML(text));
+            super.setHTML(WidgetUtil.escapeHTML(text));
         } else {
             super.setText(text);
         }

client/src/com/vaadin/client/ui/VMenuBar.java

 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.menubar.MenuBarConstants;
 
 public class VMenuBar extends SimpleFocusablePanel implements
             }
             String itemText = item.getStringAttribute("text");
             if (!htmlContentAllowed) {
-                itemText = Util.escapeHTML(itemText);
+                itemText = WidgetUtil.escapeHTML(itemText);
             }
             itemHTML.append(itemText);
             itemHTML.append("</span>");
 
                 // Make room for the scroll bar by adjusting the width of the
                 // popup
-                style.setWidth(contentWidth + Util.getNativeScrollbarSize(),
+                style.setWidth(
+                        contentWidth + WidgetUtil.getNativeScrollbarSize(),
                         Unit.PX);
                 popup.positionOrSizeUpdated();
             }
 
             // Sink the onload event for any icons. The onload
             // events are handled by the parent VMenuBar.
-            Util.sinkOnloadForImages(getElement());
+            WidgetUtil.sinkOnloadForImages(getElement());
         }
 
         @Override
 
         @Override
         public void setText(String text) {
-            setHTML(Util.escapeHTML(text));
+            setHTML(WidgetUtil.escapeHTML(text));
         }
 
         public void setEnabled(boolean enabled) {

client/src/com/vaadin/client/ui/VNotification.java

 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.aria.AriaHelper;
 import com.vaadin.shared.Position;
 import com.vaadin.shared.ui.ui.NotificationRole;
          * nudge (#8551)
          */
         if (BrowserInfo.get().isAndroid()) {
-            Util.setStyleTemporarily(getElement(), "display", "none");
+            WidgetUtil.setStyleTemporarily(getElement(), "display", "none");
         }
     }
 
             String caption = notification
                     .getStringAttribute(UIConstants.ATTRIBUTE_NOTIFICATION_CAPTION);
             if (onlyPlainText) {
-                caption = Util.escapeHTML(caption);
+                caption = WidgetUtil.escapeHTML(caption);
                 caption = caption.replaceAll("\\n", "<br />");
             }
             html += "<h1>" + caption + "</h1>";
             String message = notification
                     .getStringAttribute(UIConstants.ATTRIBUTE_NOTIFICATION_MESSAGE);
             if (onlyPlainText) {
-                message = Util.escapeHTML(message);
+                message = WidgetUtil.escapeHTML(message);
                 message = message.replaceAll("\\n", "<br />");
             }
             html += "<p>" + message + "</p>";

client/src/com/vaadin/client/ui/VOptionGroup.java

 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.UIDL;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.EventId;
 import com.vaadin.shared.ui.optiongroup.OptionGroupConstants;
 
 
             String itemHtml = opUidl.getStringAttribute("caption");
             if (!htmlContentAllowed) {
-                itemHtml = Util.escapeHTML(itemHtml);
+                itemHtml = WidgetUtil.escapeHTML(itemHtml);
             }
 
             String iconUrl = opUidl.getStringAttribute("icon");
                     op.setStyleName("v-radiobutton");
                 }
                 if (iconUrl != null && iconUrl.length() != 0) {
-                    Util.sinkOnloadForImages(op.getElement());
+                    WidgetUtil.sinkOnloadForImages(op.getElement());
                     op.addHandler(iconLoadHandler, LoadEvent.getType());
                 }
 

client/src/com/vaadin/client/ui/VOverlay.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.ComputedStyle;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 /**
  * <p>
         // IE9 and IE10 have a bug, when resize an a element with box-shadow.
         // IE9 and IE10 need explicit update to remove extra box-shadows
         if (BrowserInfo.get().isIE9() || BrowserInfo.get().isIE10()) {
-            Util.forceIERedraw(getElement());
+            WidgetUtil.forceIERedraw(getElement());
         }
     }
 

client/src/com/vaadin/client/ui/VPopupView.java

 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.ui.*;
+import com.google.gwt.user.client.ui.Focusable;
+import com.google.gwt.user.client.ui.HTML;
+import com.google.gwt.user.client.ui.HasEnabled;
+import com.google.gwt.user.client.ui.HasWidgets;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.PopupPanel;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.DeferredWorker;

client/src/com/vaadin/client/ui/VScrollTable.java

 import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.VTooltip;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.VScrollTable.VScrollTableBody.VScrollTableRow;
 import com.vaadin.client.ui.dd.DDUtil;
 import com.vaadin.client.ui.dd.VAbstractDropHandler;
 
         @Override
         public void showContextMenu(Event event) {
-            int left = Util.getTouchOrMouseClientX(event);
-            int top = Util.getTouchOrMouseClientY(event);
+            int left = WidgetUtil.getTouchOrMouseClientX(event);
+            int top = WidgetUtil.getTouchOrMouseClientY(event);
             boolean menuShown = handleBodyContextMenu(left, top);
             if (menuShown) {
                 event.stopPropagation();
 
                 // Event's reported target not always correct if event
                 // capture is in use
-                Element elementUnderMouse = Util.getElementUnderMouse(event
-                        .getNativeEvent());
+                Element elementUnderMouse = WidgetUtil
+                        .getElementUnderMouse(event.getNativeEvent());
                 if (lastMouseDownTarget != null
                         && lastMouseDownTarget.isOrHasChild(elementUnderMouse)) {
                     mouseUpPreviewMatched = true;
             int w = total;
             w += scrollBody.getCellExtraWidth() * visibleColOrder.length;
             if (willHaveScrollbarz) {
-                w += Util.getNativeScrollbarSize();
+                w += WidgetUtil.getNativeScrollbarSize();
             }
             setContentWidth(w);
         }
         availW -= scrollBody.getCellExtraWidth() * visibleColOrder.length;
 
         if (willHaveScrollbarz) {
-            availW -= Util.getNativeScrollbarSize();
+            availW -= WidgetUtil.getNativeScrollbarSize();
         }
 
         // TODO refactor this code to be the same as in resize timer
             }
             boolean needsSpaceForHorizontalSrollbar = (total > availW);
             if (needsSpaceForHorizontalSrollbar) {
-                bodyHeight += Util.getNativeScrollbarSize();
+                bodyHeight += WidgetUtil.getNativeScrollbarSize();
             }
             scrollBodyPanel.setHeight(bodyHeight + "px");
-            Util.runWebkitOverflowAutoFix(scrollBodyPanel.getElement());
+            WidgetUtil.runWebkitOverflowAutoFix(scrollBodyPanel.getElement());
         }
 
         isNewBody = false;
          * Ensures the column alignments are correct at initial loading. <br/>
          * (child components widths are correct)
          */
-        Util.runWebkitOverflowAutoFixDeferred(scrollBodyPanel.getElement());
+        WidgetUtil.runWebkitOverflowAutoFixDeferred(scrollBodyPanel
+                .getElement());
 
         hadScrollBars = willHaveScrollbarz;
     }
             case Event.ONTOUCHSTART:
             case Event.ONMOUSEDOWN:
                 if (columnReordering
-                        && Util.isTouchEventOrLeftMouseButton(event)) {
+                        && WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     if (event.getTypeInt() == Event.ONTOUCHSTART) {
                         /*
                          * prevent using this event in e.g. scrolling
             case Event.ONTOUCHEND:
             case Event.ONTOUCHCANCEL:
                 if (columnReordering
-                        && Util.isTouchEventOrLeftMouseButton(event)) {
+                        && WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     dragging = false;
                     DOM.releaseCapture(getElement());
 
-                    if (Util.isTouchEvent(event)) {
+                    if (WidgetUtil.isTouchEvent(event)) {
                         /*
                          * Prevent using in e.g. scrolling and prevent generated
                          * events.
 
                 if (!moved) {
                     // mouse event was a click to header -> sort column
-                    if (sortable && Util.isTouchEventOrLeftMouseButton(event)) {
+                    if (sortable
+                            && WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                         if (sortColumn.equals(cid)) {
                             // just toggle order
                             client.updateVariable(paintableId, "sortascending",
                         rowRequestHandler.run(); // run immediately
                     }
                     fireHeaderClickedEvent(event);
-                    if (Util.isTouchEvent(event)) {
+                    if (WidgetUtil.isTouchEvent(event)) {
                         /*
                          * Prevent using in e.g. scrolling and prevent generated
                          * events.
                 break;
             case Event.ONTOUCHMOVE:
             case Event.ONMOUSEMOVE:
-                if (dragging && Util.isTouchEventOrLeftMouseButton(event)) {
+                if (dragging && WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     if (event.getTypeInt() == Event.ONTOUCHMOVE) {
                         /*
                          * prevent using this event in e.g. scrolling
                         moved = true;
                     }
 
-                    final int clientX = Util.getTouchOrMouseClientX(event);
+                    final int clientX = WidgetUtil
+                            .getTouchOrMouseClientX(event);
                     final int x = clientX + tHead.hTableWrapper.getScrollLeft();
                     int slotX = headerX;
                     closestSlot = colIndex;
         private void onResizeEvent(Event event) {
             switch (DOM.eventGetType(event)) {
             case Event.ONMOUSEDOWN:
-                if (!Util.isTouchEventOrLeftMouseButton(event)) {
+                if (!WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     return;
                 }
                 isResizing = true;
                 DOM.eventPreventDefault(event);
                 break;
             case Event.ONMOUSEUP:
-                if (!Util.isTouchEventOrLeftMouseButton(event)) {
+                if (!WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     return;
                 }
                 isResizing = false;
                 fireColumnResizeEvent(cid, originalWidth, getColWidth(cid));
                 break;
             case Event.ONMOUSEMOVE:
-                if (!Util.isTouchEventOrLeftMouseButton(event)) {
+                if (!WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
                     return;
                 }
                 if (isResizing) {
          */
         public int getRequiredHeight() {
             return preSpacer.getOffsetHeight() + postSpacer.getOffsetHeight()
-                    + Util.getRequiredHeight(table);
+                    + WidgetUtil.getRequiredHeight(table);
         }
 
         private void constructDOM() {
                             if (!BrowserInfo.get().isAndroid()) {
                                 event.preventDefault();
                                 event.stopPropagation();
-                                Util.simulateClickFromTouchEvent(touchStart,
-                                        this);
+                                WidgetUtil.simulateClickFromTouchEvent(
+                                        touchStart, this);
                             }
                             touchStart = null;
                         }
                          */
                         if (mouseUpPreviewMatched
                                 && lastMouseDownTarget != null
-                                && lastMouseDownTarget == getElementTdOrTr(Util
+                                && lastMouseDownTarget == getElementTdOrTr(WidgetUtil
                                         .getElementUnderMouse(event))) {
                             // "Click" with left, right or middle button
 
                              * Touch has not been handled as neither context or
                              * drag start, handle it as a click.
                              */
-                            Util.simulateClickFromTouchEvent(touchStart, this);
+                            WidgetUtil.simulateClickFromTouchEvent(touchStart,
+                                    this);
                             touchStart = null;
                         }
                         touchContextProvider.cancel();
                          * the corresponding mouseup event if it's on a
                          * different part of the page.
                          */
-                        lastMouseDownTarget = getElementTdOrTr(Util
+                        lastMouseDownTarget = getElementTdOrTr(WidgetUtil
                                 .getElementUnderMouse(event));
                         mouseUpPreviewMatched = false;
                         mouseUpEventPreviewRegistration = Event
 
             private Element getElementTdOrTr(Element element) {
 
-                Widget widget = Util.findWidget(element, null);
+                Widget widget = WidgetUtil.findWidget(element, null);
 
                 if (widget != this) {
                     /*
             public void showContextMenu(Event event) {
                 if (enabled && actionKeys != null) {
                     // Show context menu if there are registered action handlers
-                    int left = Util.getTouchOrMouseClientX(event)
+                    int left = WidgetUtil.getTouchOrMouseClientX(event)
                             + Window.getScrollLeft();
-                    int top = Util.getTouchOrMouseClientY(event)
+                    int top = WidgetUtil.getTouchOrMouseClientY(event)
                             + Window.getScrollTop();
                     showContextMenu(left, top);
                 }
                         .getVisibleCellCount(); ix++) {
                     spanWidth += tHead.getHeaderCell(ix).getOffsetWidth();
                 }
-                Util.setWidthExcludingPaddingAndBorder((Element) getElement()
-                        .getChild(cellIx), spanWidth, 13, false);
+                WidgetUtil.setWidthExcludingPaddingAndBorder(
+                        (Element) getElement().getChild(cellIx), spanWidth, 13,
+                        false);
             }
         }
 
             int totalExtraWidth = scrollBody.getCellExtraWidth()
                     * visibleCellCount;
             if (willHaveScrollbars()) {
-                totalExtraWidth += Util.getNativeScrollbarSize();
+                totalExtraWidth += WidgetUtil.getNativeScrollbarSize();
             }
             availW -= totalExtraWidth;
             int forceScrollBodyWidth = -1;
                 int bodyHeight = scrollBody.getRequiredHeight();
                 boolean needsSpaceForHorizontalScrollbar = (availW < usedMinimumWidth);
                 if (needsSpaceForHorizontalScrollbar) {
-                    bodyHeight += Util.getNativeScrollbarSize();
+                    bodyHeight += WidgetUtil.getNativeScrollbarSize();
                 }
                 int heightBefore = getOffsetHeight();
                 scrollBodyPanel.setHeight(bodyHeight + "px");
      */
     private int getBorderWidth() {
         if (borderWidth < 0) {
-            borderWidth = Util.measureHorizontalPaddingAndBorder(
+            borderWidth = WidgetUtil.measureHorizontalPaddingAndBorder(
                     scrollBodyPanel.getElement(), 2);
             if (borderWidth < 0) {
                 borderWidth = 0;
             Class<? extends Widget> clazz = getRowClass();
             VScrollTableRow row = null;
             if (clazz != null) {
-                row = Util.findWidget(elementOver, clazz);
+                row = WidgetUtil.findWidget(elementOver, clazz);
             }
             if (row != null) {
                 dropDetails.overkey = row.rowKey;
          * FIXME The next line doesn't always do what expected, because if the
          * row is not in the DOM it won't scroll to it.
          */
-        Util.scrollIntoViewVertically(row.getElement());
+        WidgetUtil.scrollIntoViewVertically(row.getElement());
     }
 
     /**
              * ...and sometimes it sends blur events even though the focus
              * handler is still active. (#10464)
              */
-            Element focusedElement = Util.getIEFocusedElement();
+            Element focusedElement = WidgetUtil.getFocusedElement();
             if (Util.getConnectorForElement(client, getParent(), focusedElement) == this
                     && focusedElement != null
                     && focusedElement != scrollBodyPanel.getFocusElement()) {
 
     @Override
     public String getSubPartName(com.google.gwt.user.client.Element subElement) {
-        Widget widget = Util.findWidget(subElement, null);
+        Widget widget = WidgetUtil.findWidget(subElement, null);
         if (widget instanceof HeaderCell) {
             return SUBPART_HEADER + "[" + tHead.visibleCells.indexOf(widget)
                     + "]";

client/src/com/vaadin/client/ui/VSlider.java

 import com.google.gwt.user.client.ui.HasValue;
 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.BrowserInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.slider.SliderOrientation;
 
 public class VSlider extends SimpleFocusablePanel implements Field,
         } else if (DOM.eventGetType(event) == Event.ONMOUSEDOWN) {
             feedbackPopup.show();
         }
-        if (Util.isTouchEvent(event)) {
+        if (WidgetUtil.isTouchEvent(event)) {
             event.preventDefault(); // avoid simulated events
             event.stopPropagation();
         }
      */
     protected int getEventPosition(Event event) {
         if (isVertical()) {
-            return Util.getTouchOrMouseClientY(event);
+            return WidgetUtil.getTouchOrMouseClientY(event);
         } else {
-            return Util.getTouchOrMouseClientX(event);
+            return WidgetUtil.getTouchOrMouseClientX(event);
         }
     }
 

client/src/com/vaadin/client/ui/VTabsheet.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.Focusable;
 import com.vaadin.client.TooltipInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VCaption;
 import com.vaadin.client.VTooltip;
 import com.vaadin.client.ui.aria.AriaHelper;
         public int getRequiredWidth() {
             int width = super.getRequiredWidth();
             if (closeButton != null) {
-                width += Util.getRequiredWidth(closeButton);
+                width += WidgetUtil.getRequiredWidth(closeButton);
             }
             return width;
         }
 
     /** For internal use only. May be removed or replaced in the future. */
     public int getContentAreaBorderWidth() {
-        return Util.measureHorizontalBorder(contentNode);
+        return WidgetUtil.measureHorizontalBorder(contentNode);
     }
 
     @Override

client/src/com/vaadin/client/ui/VTextArea.java

 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
 import com.vaadin.client.BrowserInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.dd.DragImageModifier;
 
 /**
             // and reattach the whole TextArea.
             // Webkit fails to properly reflow the text when enabling wrapping,
             // same workaround
-            Util.detachAttach(getElement());
+            WidgetUtil.detachAttach(getElement());
         }
         this.wordwrap = wordwrap;
     }

client/src/com/vaadin/client/ui/VTextField.java

 import com.google.gwt.user.client.ui.TextBoxBase;
 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.BrowserInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.EventId;
 import com.vaadin.shared.ui.textfield.TextFieldConstants;
 
      * @return true iff the value was updated
      */
     protected boolean updateCursorPosition() {
-        if (Util.isAttachedAndDisplayed(this)) {
+        if (WidgetUtil.isAttachedAndDisplayed(this)) {
             int cursorPos = getCursorPos();
             if (lastCursorPos != cursorPos) {
                 client.updateVariable(paintableId,

client/src/com/vaadin/client/ui/VTree.java

 import com.vaadin.client.MouseEventDetailsBuilder;
 import com.vaadin.client.UIDL;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.aria.AriaHelper;
 import com.vaadin.client.ui.aria.HandlesAriaCaption;
 import com.vaadin.client.ui.dd.DDUtil;
     }
 
     private String findCurrentMouseOverKey(Element elementOver) {
-        TreeNode treeNode = Util.findWidget(elementOver, TreeNode.class);
+        TreeNode treeNode = WidgetUtil.findWidget(elementOver, TreeNode.class);
         return treeNode == null ? null : treeNode.key;
     }
 
          * Scrolls the caption into view
          */
         public void scrollIntoView() {
-            Util.scrollIntoViewVertically(nodeCaptionDiv);
+            WidgetUtil.scrollIntoViewVertically(nodeCaptionDiv);
         }
 
         public void setIcon(String iconUrl, String altText) {
             return "fe";
         }
 
-        TreeNode treeNode = Util.findWidget(subElement, TreeNode.class);
+        TreeNode treeNode = WidgetUtil.findWidget(subElement, TreeNode.class);
         if (treeNode == null) {
             // Did not click on a node, let somebody else take care of the
             // locator string

client/src/com/vaadin/client/ui/VTreeTable.java

 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ComputedStyle;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.VTreeTable.VTreeTableScrollBody.VTreeTableRow;
 
 public class VTreeTable extends VScrollTable {
                         .getVisibleCellCount(); ix++) {
                     spanWidth += tHead.getHeaderCell(ix).getOffsetWidth();
                 }
-                Util.setWidthExcludingPaddingAndBorder((Element) getElement()
-                        .getChild(cellIx), spanWidth, 13, false);
+                WidgetUtil.setWidthExcludingPaddingAndBorder(
+                        (Element) getElement().getChild(cellIx), spanWidth, 13,
+                        false);
             }
         }
 

client/src/com/vaadin/client/ui/VTwinColSelect.java

 import com.google.gwt.user.client.ui.Panel;
 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.twincolselect.TwinColSelectConstants;
 
 public class VTwinColSelect extends VOptionGroupBase implements KeyDownHandler,
 
     /** For internal use only. May be removed or replaced in the future. */
     public void setInternalHeights() {
-        int captionHeight = Util.getRequiredHeight(captionWrapper);
+        int captionHeight = WidgetUtil.getRequiredHeight(captionWrapper);
         int totalHeight = getOffsetHeight();
 
         String selectHeight = (totalHeight - captionHeight) + "px";
     /** For internal use only. May be removed or replaced in the future. */
     public void setInternalWidths() {
         getElement().getStyle().setPosition(Position.RELATIVE);
-        int bordersAndPaddings = Util.measureHorizontalPaddingAndBorder(
+        int bordersAndPaddings = WidgetUtil.measureHorizontalPaddingAndBorder(
                 buttons.getElement(), 0);
 
-        int buttonWidth = Util.getRequiredWidth(buttons);
+        int buttonWidth = WidgetUtil.getRequiredWidth(buttons);
         int totalWidth = getOffsetWidth();
 
         int spaceForSelect = (totalWidth - buttonWidth - bordersAndPaddings) / 2;
             if (options.getElement() == subElement) {
                 return SUBPART_OPTION_SELECT;
             } else {
-                int idx = Util.getChildElementIndex(subElement);
+                int idx = WidgetUtil.getChildElementIndex(subElement);
                 return SUBPART_OPTION_SELECT_ITEM + idx;
             }
         } else if (selections.getElement().isOrHasChild(subElement)) {
             if (selections.getElement() == subElement) {
                 return SUBPART_SELECTION_SELECT;
             } else {
-                int idx = Util.getChildElementIndex(subElement);
+                int idx = WidgetUtil.getChildElementIndex(subElement);
                 return SUBPART_SELECTION_SELECT_ITEM + idx;
             }
         } else if (add.getElement().isOrHasChild(subElement)) {

client/src/com/vaadin/client/ui/VUI.java

 import com.vaadin.client.Focusable;
 import com.vaadin.client.LayoutManager;
 import com.vaadin.client.Profiler;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.ui.ShortcutActionHandler.ShortcutActionHandlerOwner;
 import com.vaadin.client.ui.TouchScrollDelegate.TouchScrollHandler;
      * @param focusedElement
      */
     public void storeFocus() {
-        storedFocus = Util.getFocusedElement();
+        storedFocus = WidgetUtil.getFocusedElement();
     }
 
     /**

client/src/com/vaadin/client/ui/VWindow.java

 
 package com.vaadin.client.ui;
 
-import static com.vaadin.client.Util.isFocusedElementEditable;
+import static com.vaadin.client.WidgetUtil.isFocusedElementEditable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import com.vaadin.client.ConnectorMap;
 import com.vaadin.client.Focusable;
 import com.vaadin.client.LayoutManager;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.debug.internal.VDebugWindow;
 import com.vaadin.client.ui.ShortcutActionHandler.ShortcutActionHandlerOwner;
 import com.vaadin.client.ui.aria.AriaHelper;
              * ticket #11994 which was changing the size to 110% was replaced
              * with this due to ticket #12943
              */
-            Util.runWebkitOverflowAutoFix(contents.getFirstChildElement());
+            WidgetUtil
+                    .runWebkitOverflowAutoFix(contents.getFirstChildElement());
         }
     }
 
     public void setCaption(String c, String iconURL, boolean asHtml) {
         String html = c;
         if (!asHtml) {
-            c = Util.escapeHTML(c);
+            c = WidgetUtil.escapeHTML(c);
         }
 
         // Provide information to assistive device users that a sub window was
     }
 
     private void onResizeEvent(Event event) {
-        if (resizable && Util.isTouchEventOrLeftMouseButton(event)) {
+        if (resizable && WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
             switch (event.getTypeInt()) {
             case Event.ONMOUSEDOWN:
             case Event.ONTOUCHSTART:
                     resizeBox.getStyle().setVisibility(Visibility.HIDDEN);
                 }
                 resizing = true;
-                startX = Util.getTouchOrMouseClientX(event);
-                startY = Util.getTouchOrMouseClientY(event);
+                startX = WidgetUtil.getTouchOrMouseClientX(event);
+                startY = WidgetUtil.getTouchOrMouseClientY(event);
                 origW = getElement().getOffsetWidth();
                 origH = getElement().getOffsetHeight();
                 DOM.setCapture(getElement());
             return;
         }
 
-        int w = Util.getTouchOrMouseClientX(event) - startX + origW;
-        int h = Util.getTouchOrMouseClientY(event) - startY + origH;
+        int w = WidgetUtil.getTouchOrMouseClientX(event) - startX + origW;
+        int h = WidgetUtil.getTouchOrMouseClientY(event) - startY + origH;
 
         w = Math.max(w, getMinWidth());
         h = Math.max(h, getMinHeight());
     }
 
     private void onDragEvent(Event event) {
-        if (!Util.isTouchEventOrLeftMouseButton(event)) {
+        if (!WidgetUtil.isTouchEventOrLeftMouseButton(event)) {
             return;
         }
 
             centered = false;
             if (cursorInsideBrowserContentArea(event)) {
                 // Only drag while cursor is inside the browser client area
-                final int x = Util.getTouchOrMouseClientX(event) - startX
+                final int x = WidgetUtil.getTouchOrMouseClientX(event) - startX
                         + origX;
-                final int y = Util.getTouchOrMouseClientY(event) - startY
+                final int y = WidgetUtil.getTouchOrMouseClientY(event) - startY
                         + origY;
                 setPopupPosition(x, y);
             }
         if (draggable) {
             showDraggingCurtain();
             dragging = true;
-            startX = Util.getTouchOrMouseClientX(event);
-            startY = Util.getTouchOrMouseClientY(event);
+            startX = WidgetUtil.getTouchOrMouseClientX(event);
+            startY = WidgetUtil.getTouchOrMouseClientY(event);
             origX = DOM.getAbsoluteLeft(getElement());
             origY = DOM.getAbsoluteTop(getElement());
             DOM.setCapture(getElement());
             if (!DOM.isOrHasChild(getTopmostWindow().getElement(), target)) {
                 // not within the modal window, but let's see if it's in the
                 // debug window
-                Widget w = Util.findWidget(target, null);
+                Widget w = WidgetUtil.findWidget(target, null);
                 while (w != null) {
                     if (w instanceof VDebugWindow) {
                         return true; // allow debug-window clicks

client/src/com/vaadin/client/ui/accordion/AccordionConnector.java

 
 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.ConnectorHierarchyChangeEvent;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.SimpleManagedLayout;
 import com.vaadin.client.ui.VAccordion;
                     usedPixels += item.getCaptionHeight();
                 } else {
                     // This includes the captionNode borders
-                    usedPixels += Util.getRequiredHeight(item.getElement());
+                    usedPixels += WidgetUtil.getRequiredHeight(item
+                            .getElement());
                 }
             }
             int rootElementInnerHeight = getLayoutManager().getInnerHeight(

client/src/com/vaadin/client/ui/calendar/CalendarConnector.java

 import com.vaadin.client.Paintable;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.communication.RpcProxy;
 import com.vaadin.client.communication.StateChangeEvent;
     @Override
     public TooltipInfo getTooltipInfo(com.google.gwt.dom.client.Element element) {
         TooltipInfo tooltipInfo = null;
-        Widget w = Util.findWidget(element, null);
+        Widget w = WidgetUtil.findWidget(element, null);
         if (w instanceof HasTooltipKey) {
             tooltipInfo = GWT.create(TooltipInfo.class);
             String title = tooltips.get(((HasTooltipKey) w).getTooltipKey());

client/src/com/vaadin/client/ui/calendar/schedule/DateCell.java

 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
 import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 public class DateCell extends FocusableComplexPanel implements
         MouseDownHandler, MouseMoveHandler, MouseUpHandler, KeyDownHandler,
             addStyleDependentName("Hsized");
 
             width = getOffsetWidth()
-                    - Util.measureHorizontalBorder(getElement());
+                    - WidgetUtil.measureHorizontalBorder(getElement());
             // Update moveWidth for any DateCellDayEvent child
             updateEventCellsWidth();
             recalculateEventWidths();
     }
 
     public int getSlotBorder() {
-        return Util.measureVerticalBorder(slotElements[0]);
+        return WidgetUtil.measureVerticalBorder(slotElements[0]);
     }
 
     private void drawDayEvents(List<DateCellGroup> groups) {

client/src/com/vaadin/client/ui/calendar/schedule/DateCellContainer.java

 import com.google.gwt.event.dom.client.MouseUpHandler;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.VCalendar;
 
 /**
 
     public static int measureBorderWidth(DateCellContainer dc) {
         if (borderWidth == -1) {
-            borderWidth = Util.measureHorizontalBorder(dc.getElement());
+            borderWidth = WidgetUtil.measureHorizontalBorder(dc.getElement());
         }
         return borderWidth;
     }

client/src/com/vaadin/client/ui/calendar/schedule/DateCellDayEvent.java

 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
 import com.google.gwt.user.client.ui.HorizontalPanel;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.calendar.DateConstants;
 
 /**
      */
     private void updateCaptions(boolean bigMode) {
         String innerHtml;
-        String escapedCaption = Util.escapeHTML(calendarEvent.getCaption());
+        String escapedCaption = WidgetUtil.escapeHTML(calendarEvent
+                .getCaption());
         String timeAsText = calendarEvent.getTimeAsText();
         if (bigMode) {
             innerHtml = "<span>" + timeAsText + "</span><br />"

client/src/com/vaadin/client/ui/calendar/schedule/WeekGrid.java

 import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.DateTimeService;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.VCalendar;
 import com.vaadin.shared.ui.calendar.DateConstants;
 
             // Otherwise the scroll wrapper is somehow too narrow = horizontal
             // scroll
             wrapper.setWidth(content.getOffsetWidth()
-                    + Util.getNativeScrollbarSize() + "px");
+                    + WidgetUtil.getNativeScrollbarSize() + "px");
 
             this.width = content.getOffsetWidth() - timebar.getOffsetWidth();
 
                     - timebar.getOffsetWidth();
 
             if (isVerticalScrollable() && width != -1) {
-                this.width = this.width - Util.getNativeScrollbarSize();
+                this.width = this.width - WidgetUtil.getNativeScrollbarSize();
             }
             updateCellWidths();
         }

client/src/com/vaadin/client/ui/calendar/schedule/dd/CalendarMonthDropHandler.java

 
 import com.google.gwt.dom.client.Element;
 import com.google.gwt.user.client.DOM;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.calendar.CalendarConnector;
 import com.vaadin.client.ui.calendar.schedule.SimpleDayCell;
 import com.vaadin.client.ui.dd.VAcceptCallback;
     protected void dragAccepted(VDragEvent drag) {
         deEmphasis();
         currentTargetElement = drag.getElementOver();
-        currentTargetDay = Util.findWidget(currentTargetElement,
+        currentTargetDay = WidgetUtil.findWidget(currentTargetElement,
                 SimpleDayCell.class);
         emphasis();
     }

client/src/com/vaadin/client/ui/calendar/schedule/dd/CalendarWeekDropHandler.java

 
 import com.google.gwt.dom.client.Element;
 import com.google.gwt.user.client.DOM;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.calendar.CalendarConnector;
 import com.vaadin.client.ui.calendar.schedule.DateCell;
 import com.vaadin.client.ui.calendar.schedule.DateCellDayEvent;
     protected void dragAccepted(VDragEvent drag) {
         deEmphasis();
         currentTargetElement = drag.getElementOver();
-        currentTargetDay = Util
-                .findWidget(currentTargetElement, DateCell.class);
+        currentTargetDay = WidgetUtil.findWidget(currentTargetElement,
+                DateCell.class);
         emphasis();
     }
 
         return DOM.isOrHasChild(weekGridElement, elementOver)
                 && !DOM.isOrHasChild(timeBarElement, elementOver)
                 && todayBarElement != elementOver
-                && (Util.findWidget(elementOver, DateCellDayEvent.class) == null);
+                && (WidgetUtil.findWidget(elementOver, DateCellDayEvent.class) == null);
     }
 
     /*

client/src/com/vaadin/client/ui/dd/DDUtil.java

 import com.google.gwt.dom.client.Element;
 import com.google.gwt.dom.client.NativeEvent;
 import com.google.gwt.user.client.Window;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.dd.HorizontalDropLocation;
 import com.vaadin.shared.ui.dd.VerticalDropLocation;
 
 
     public static VerticalDropLocation getVerticalDropLocation(Element element,
             int offsetHeight, NativeEvent event, double topBottomRatio) {
-        int clientY = Util.getTouchOrMouseClientY(event);
+        int clientY = WidgetUtil.getTouchOrMouseClientY(event);
         return getVerticalDropLocation(element, offsetHeight, clientY,
                 topBottomRatio);
     }
 
     public static HorizontalDropLocation getHorizontalDropLocation(
             Element element, NativeEvent event, double leftRightRatio) {
-        int clientX = Util.getTouchOrMouseClientX(event);
+        int clientX = WidgetUtil.getTouchOrMouseClientX(event);
 
         // Event coordinates are relative to the viewport, element absolute
         // position is relative to the document. Make element position relative

client/src/com/vaadin/client/ui/dd/VDragAndDropManager.java

 import com.vaadin.client.MouseEventDetailsBuilder;
 import com.vaadin.client.Profiler;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.ValueMap;
 import com.vaadin.client.ui.VOverlay;
                 targetElement = targetNode.getParentElement();
             }
 
-            if (Util.isTouchEvent(nativeEvent) || dragElement != null) {
+            if (WidgetUtil.isTouchEvent(nativeEvent) || dragElement != null) {
                 // to detect the "real" target, hide dragelement temporary and
                 // use elementFromPoint
                 String display = dragElement.getStyle().getDisplay();
                 dragElement.getStyle().setDisplay(Display.NONE);
                 try {
-                    int x = Util.getTouchOrMouseClientX(nativeEvent);
-                    int y = Util.getTouchOrMouseClientY(nativeEvent);
+                    int x = WidgetUtil.getTouchOrMouseClientX(nativeEvent);
+                    int y = WidgetUtil.getTouchOrMouseClientY(nativeEvent);
                     // Util.browserDebugger();
-                    targetElement = Util.getElementFromPoint(x, y);
+                    targetElement = WidgetUtil.getElementFromPoint(x, y);
                     if (targetElement == null) {
                         // ApplicationConnection.getConsole().log(
                         // "Event on dragImage, ignored");
             deferredStartRegistration = Event
                     .addNativePreviewHandler(new NativePreviewHandler() {
 
-                        private int startX = Util
+                        private int startX = WidgetUtil
                                 .getTouchOrMouseClientX(currentDrag
                                         .getCurrentGwtEvent());
-                        private int startY = Util
+                        private int startY = WidgetUtil
                                 .getTouchOrMouseClientY(currentDrag
                                         .getCurrentGwtEvent());
 
                                 }
                             case Event.ONMOUSEMOVE:
                             case Event.ONTOUCHMOVE:
-                                int currentX = Util
+                                int currentX = WidgetUtil
                                         .getTouchOrMouseClientX(event
                                                 .getNativeEvent());
-                                int currentY = Util
+                                int currentY = WidgetUtil
                                         .getTouchOrMouseClientY(event
                                                 .getNativeEvent());
                                 if (Math.abs(startX - currentX) > 3
     private void updateDragImagePosition() {
         if (currentDrag.getCurrentGwtEvent() != null && dragElement != null) {
             Style style = dragElement.getStyle();
-            int clientY = Util.getTouchOrMouseClientY(currentDrag
+            int clientY = WidgetUtil.getTouchOrMouseClientY(currentDrag
                     .getCurrentGwtEvent());
-            int clientX = Util.getTouchOrMouseClientX(currentDrag
+            int clientX = WidgetUtil.getTouchOrMouseClientX(currentDrag
                     .getCurrentGwtEvent());
             style.setTop(clientY, Unit.PX);
             style.setLeft(clientX, Unit.PX);
      */
     private VDropHandler findDragTarget(Element element) {
         try {
-            Widget w = Util.findWidget(element, null);
+            Widget w = WidgetUtil.findWidget(element, null);
             if (w == null) {
                 return null;
             }

client/src/com/vaadin/client/ui/dd/VDragEvent.java

 import com.google.gwt.user.client.Event;
 import com.google.gwt.user.client.EventListener;
 import com.vaadin.client.BrowserInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 
 /**
  * DragEvent used by Vaadin client side engine. Supports components, items,
         if (alignImageToEvent) {
             int absoluteTop = element.getAbsoluteTop();
             int absoluteLeft = element.getAbsoluteLeft();
-            int clientX = Util.getTouchOrMouseClientX(startEvent);
-            int clientY = Util.getTouchOrMouseClientY(startEvent);
+            int clientX = WidgetUtil.getTouchOrMouseClientX(startEvent);
+            int clientY = WidgetUtil.getTouchOrMouseClientY(startEvent);
             int offsetX = absoluteLeft - clientX;
             int offsetY = absoluteTop - clientY;
             setDragImage(cloneNode, offsetX, offsetY);

client/src/com/vaadin/client/ui/formlayout/FormLayoutConnector.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.ConnectorHierarchyChangeEvent;
 import com.vaadin.client.TooltipInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.AbstractFieldConnector;
 import com.vaadin.client.ui.AbstractLayoutConnector;
         TooltipInfo info = null;
 
         if (element != getWidget().getElement()) {
-            Object node = Util.findWidget(element, VFormLayout.Caption.class);
+            Object node = WidgetUtil.findWidget(element,
+                    VFormLayout.Caption.class);
 
             if (node != null) {
                 VFormLayout.Caption caption = (VFormLayout.Caption) node;
                 info = caption.getOwner().getTooltipInfo(element);
             } else {
 
-                node = Util.findWidget(element, VFormLayout.ErrorFlag.class);
+                node = WidgetUtil.findWidget(element,
+                        VFormLayout.ErrorFlag.class);
 
                 if (node != null) {
                     VFormLayout.ErrorFlag flag = (VFormLayout.ErrorFlag) node;

client/src/com/vaadin/client/ui/label/LabelConnector.java

 import com.google.gwt.dom.client.Document;
 import com.google.gwt.dom.client.PreElement;
 import com.vaadin.client.Profiler;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.AbstractComponentConnector;
 import com.vaadin.client.ui.VLabel;
 
         if (sinkOnloads) {
             Profiler.enter("LabelConnector.onStateChanged sinkOnloads");
-            Util.sinkOnloadForImages(getWidget().getElement());
+            WidgetUtil.sinkOnloadForImages(getWidget().getElement());
             Profiler.leave("LabelConnector.onStateChanged sinkOnloads");
         }
     }

client/src/com/vaadin/client/ui/layout/LayoutDependencyTree.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.Util;
 import com.vaadin.client.VConsole;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.ManagedLayout;
 import com.vaadin.shared.AbstractComponentState;
 
     }
 
     private static String getCompactConnectorString(ServerConnector connector) {
-        return Util.getSimpleName(connector) + " ("
+        return WidgetUtil.getSimpleName(connector) + " ("
                 + connector.getConnectorId() + ")";
     }
 

client/src/com/vaadin/client/ui/menubar/MenuBarConnector.java

 import com.vaadin.client.Paintable;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.AbstractComponentConnector;
 import com.vaadin.client.ui.ImageIcon;
 import com.vaadin.client.ui.SimpleManagedLayout;
 
             if (moreItemUIDL.hasAttribute("icon")) {
                 itemHTML.append("<img src=\""
-                        + Util.escapeAttribute(client
+                        + WidgetUtil.escapeAttribute(client
                                 .translateVaadinUri(moreItemUIDL
                                         .getStringAttribute("icon")))
                         + "\" class=\"" + ImageIcon.CLASSNAME

client/src/com/vaadin/client/ui/orderedlayout/AbstractOrderedLayoutConnector.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.communication.StateChangeEvent.StateChangeHandler;
 import com.vaadin.client.ui.AbstractFieldConnector;
     @Override
     public TooltipInfo getTooltipInfo(com.google.gwt.dom.client.Element element) {
         if (element != getWidget().getElement()) {
-            Slot slot = Util.findWidget(element, Slot.class);
+            Slot slot = WidgetUtil.findWidget(element, Slot.class);
             if (slot != null && slot.getCaptionElement() != null
                     && slot.getParent() == getWidget()
                     && slot.getCaptionElement().isOrHasChild(element)) {

client/src/com/vaadin/client/ui/orderedlayout/Slot.java

 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.LayoutManager;
 import com.vaadin.client.StyleConstants;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.FontIcon;
 import com.vaadin.client.ui.Icon;
 import com.vaadin.client.ui.ImageIcon;
         public void onElementResize(ElementResizeEvent e) {
             Element caption = getCaptionElement();
             if (caption != null) {
-                Util.forceIE8Redraw(caption);
+                WidgetUtil.forceIE8Redraw(caption);
             }
         }
     };
 
         // Caption wrappers
         Widget widget = getWidget();
-        final Element focusedElement = Util.getFocusedElement();
+        final Element focusedElement = WidgetUtil.getFocusedElement();
         // By default focus will not be lost
         boolean focusLost = false;
         if (captionText != null || icon != null || error != null || required) {
 
         if (focusLost) {
             // Find out what element is currently focused.
-            Element currentFocus = Util.getFocusedElement();
+            Element currentFocus = WidgetUtil.getFocusedElement();
             if (currentFocus != null
                     && currentFocus.equals(Document.get().getBody())) {
                 // Focus has moved to BodyElement and should be moved back to
 
                     @Override
                     public void run() {
-                        if (Util.getFocusedElement() == null) {
+                        if (WidgetUtil.getFocusedElement() == null) {
                             // This should never become an infinite loop and
                             // even if it does it will be stopped once something
                             // is done with the browser.
                             schedule(25);
-                        } else if (Util.getFocusedElement().equals(
+                        } else if (WidgetUtil.getFocusedElement().equals(
                                 Document.get().getBody())) {
                             // Focus found it's way to BodyElement. Now it can
                             // be restored

client/src/com/vaadin/client/ui/orderedlayout/VAbstractOrderedLayout.java

 import com.vaadin.client.LayoutManager;
 import com.vaadin.client.Profiler;
 import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.shared.ui.MarginInfo;
 
 /**
                 }
             }
         }
-        Util.forceIE8Redraw(getElement());
+        WidgetUtil.forceIE8Redraw(getElement());
     }
 
     /**

client/src/com/vaadin/client/ui/table/TableConnector.java

 import com.vaadin.client.ServerConnector;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.AbstractHasComponentsConnector;
 import com.vaadin.client.ui.PostLayoutListener;
 import com.vaadin.client.ui.VScrollTable;
                 @Override
                 public void execute() {
                     // IE8 needs some hacks to measure sizes correctly
-                    Util.forceIE8Redraw(getWidget().getElement());
+                    WidgetUtil.forceIE8Redraw(getWidget().getElement());
 
                     getLayoutManager().setNeedsMeasure(TableConnector.this);
                     ServerConnector parent = getParent();
         TooltipInfo info = null;
 
         if (element != getWidget().getElement()) {
-            Object node = Util.findWidget(element, VScrollTableRow.class);
+            Object node = WidgetUtil.findWidget(element, VScrollTableRow.class);
 
             if (node != null) {
                 VScrollTableRow row = (VScrollTableRow) node;

client/src/com/vaadin/client/ui/tabsheet/TabsheetConnector.java

 import com.vaadin.client.ComponentConnector;
 import com.vaadin.client.ConnectorHierarchyChangeEvent;
 import com.vaadin.client.TooltipInfo;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.SimpleManagedLayout;
 import com.vaadin.client.ui.VTabsheet;
 
         // Find a tooltip for the tab, if the element is a tab
         if (element != getWidget().getElement()) {
-            Object node = Util.findWidget(element, VTabsheet.TabCaption.class);
+            Object node = WidgetUtil.findWidget(element,
+                    VTabsheet.TabCaption.class);
 
             if (node != null) {
                 VTabsheet.TabCaption caption = (VTabsheet.TabCaption) node;

client/src/com/vaadin/client/ui/textarea/TextAreaConnector.java

 import com.google.gwt.dom.client.Element;
 import com.google.gwt.event.dom.client.MouseUpEvent;
 import com.google.gwt.event.dom.client.MouseUpHandler;
-import com.vaadin.client.Util.CssSize;
+import com.vaadin.client.WidgetUtil.CssSize;
 import com.vaadin.client.ui.VTextArea;
 import com.vaadin.client.ui.textfield.TextFieldConnector;
 import com.vaadin.shared.ui.Connect;

client/src/com/vaadin/client/ui/tree/TreeConnector.java

 import com.vaadin.client.Paintable;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.VConsole;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.AbstractComponentConnector;
         }
 
         // IE8 needs a hack to measure the tree again after update
-        Util.forceIE8Redraw(getWidget().getElement());
+        WidgetUtil.forceIE8Redraw(getWidget().getElement());
 
         getWidget().rendering = false;
 
 
         // Try to find a tooltip for a node
         if (element != getWidget().getElement()) {
-            Object node = Util.findWidget(element, TreeNode.class);
+            Object node = WidgetUtil.findWidget(element, TreeNode.class);
 
             if (node != null) {
                 TreeNode tnode = (TreeNode) node;

client/src/com/vaadin/client/ui/treetable/TreeTableConnector.java

 import com.vaadin.client.ApplicationConnection;
 import com.vaadin.client.TooltipInfo;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.FocusableScrollPanel;
 import com.vaadin.client.ui.VScrollTable.VScrollTableBody.VScrollTableRow;
 import com.vaadin.client.ui.VTreeTable;
         TooltipInfo info = null;
 
         if (element != getWidget().getElement()) {
-            Object node = Util.findWidget(element, VTreeTableRow.class);
+            Object node = WidgetUtil.findWidget(element, VTreeTableRow.class);
 
             if (node != null) {
                 VTreeTableRow row = (VTreeTableRow) node;

client/src/com/vaadin/client/ui/window/WindowConnector.java

 import com.vaadin.client.LayoutManager;
 import com.vaadin.client.Paintable;
 import com.vaadin.client.UIDL;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.communication.RpcProxy;
 import com.vaadin.client.communication.StateChangeEvent;
 import com.vaadin.client.ui.AbstractSingleComponentContainerConnector;
             Style childStyle = layoutElement.getStyle();
 
             // IE8 needs some hackery to measure its content correctly
-            Util.forceIE8Redraw(layoutElement);
+            WidgetUtil.forceIE8Redraw(layoutElement);
 
             if (content.isRelativeHeight() && !BrowserInfo.get().isIE9()) {
                 childStyle.setPosition(Position.ABSOLUTE);

client/src/com/vaadin/client/widget/escalator/ScrollbarBundle.java

 import com.google.gwt.user.client.EventListener;
 import com.google.gwt.user.client.Timer;
 import com.vaadin.client.DeferredWorker;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.widget.grid.events.ScrollEvent;
 import com.vaadin.client.widget.grid.events.ScrollHandler;
 
         double oldScrollPos = scrollPos;
         scrollPos = Math.max(0, Math.min(maxScrollPos, truncate(px)));
 
-        if (!Util.pixelValuesEqual(oldScrollPos, scrollPos)) {
+        if (!WidgetUtil.pixelValuesEqual(oldScrollPos, scrollPos)) {
             if (isInvisibleScrollbar) {
                 invisibleScrollbarTemporaryResizer.show();
             }

client/src/com/vaadin/client/widget/grid/selection/MultiSelectionRenderer.java

 import com.google.gwt.user.client.Event;
 import com.google.gwt.user.client.Event.NativePreviewEvent;
 import com.google.gwt.user.client.Event.NativePreviewHandler;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.renderers.ComplexRenderer;
 import com.vaadin.client.widget.grid.CellReference;
 import com.vaadin.client.widget.grid.RendererCellReference;
 
             int constrainedPageY = Math.max(bodyAbsoluteTop,
                     Math.min(bodyAbsoluteBottom, pageY));
-            int logicalRow = getLogicalRowIndex(Util.getElementFromPoint(
+            int logicalRow = getLogicalRowIndex(WidgetUtil.getElementFromPoint(
                     initialPageX, constrainedPageY));
 
             int incrementOrDecrement = (logicalRow > lastModifiedLogicalRow) ? 1
                 switch (event.getTypeInt()) {
                 case Event.ONMOUSEMOVE:
                 case Event.ONTOUCHMOVE:
-                    pageY = Util.getTouchOrMouseClientY(nativeEvent);
-                    pageX = Util.getTouchOrMouseClientX(nativeEvent);
+                    pageY = WidgetUtil.getTouchOrMouseClientY(nativeEvent);
+                    pageX = WidgetUtil.getTouchOrMouseClientX(nativeEvent);
                     autoScroller.updatePointerCoords(pageX, pageY);
                     break;
                 case Event.ONMOUSEUP:

client/src/com/vaadin/client/widgets/Escalator.java

 import com.vaadin.client.BrowserInfo;
 import com.vaadin.client.DeferredWorker;
 import com.vaadin.client.Profiler;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.widget.escalator.Cell;
 import com.vaadin.client.widget.escalator.ColumnConfiguration;
 import com.vaadin.client.widget.escalator.EscalatorUpdater;
 
             final double viewportStartPx = getScrollLeft();
             double viewportEndPx = viewportStartPx
-                    + Util.getRequiredWidthBoundingClientRectDouble(getElement())
+                    + WidgetUtil
+                            .getRequiredWidthBoundingClientRectDouble(getElement())
                     - frozenPixels;
             if (verticalScrollbar.showsScrollHandle()) {
-                viewportEndPx -= Util.getNativeScrollbarSize();
+                viewportEndPx -= WidgetUtil.getNativeScrollbarSize();
             }
 
             final double scrollLeft = getScrollPos(destination, targetStartPx,
                 final boolean isVisible = !cell.getStyle().getDisplay()
                         .equals(Display.NONE.getCssName());
                 if (isVisible) {
-                    maxWidth = Math
-                            .max(maxWidth,
-                                    Util.getRequiredWidthBoundingClientRectDouble(cell));
+                    maxWidth = Math.max(maxWidth, WidgetUtil
+                            .getRequiredWidthBoundingClientRectDouble(cell));
                 }
                 row = TableRowElement.as(row.getNextSiblingElement());
             }
                 cellClone.getStyle().clearWidth();
 
                 rowElement.insertBefore(cellClone, cellOriginal);
-                double requiredWidth = Util
+                double requiredWidth = WidgetUtil
                         .getRequiredWidthBoundingClientRectDouble(cellClone);
 
                 if (BrowserInfo.get().isIE9()) {
         private TableRowElement getEscalatorRowWithFocus() {
             TableRowElement rowContainingFocus = null;
 
-            final Element focusedElement = Util.getFocusedElement();
+            final Element focusedElement = WidgetUtil.getFocusedElement();
 
             if (focusedElement != null && root.isOrHasChild(focusedElement)) {
                 Element e = focusedElement;
 
         root.appendChild(verticalScrollbar.getElement());
         verticalScrollbar.addScrollHandler(scrollHandler);
-        verticalScrollbar.setScrollbarThickness(Util.getNativeScrollbarSize());
+        verticalScrollbar.setScrollbarThickness(WidgetUtil
+                .getNativeScrollbarSize());
 
         root.appendChild(horizontalScrollbar.getElement());
         horizontalScrollbar.addScrollHandler(scrollHandler);
-        horizontalScrollbar
-                .setScrollbarThickness(Util.getNativeScrollbarSize());
+        horizontalScrollbar.setScrollbarThickness(WidgetUtil
+                .getNativeScrollbarSize());
         horizontalScrollbar
                 .addVisibilityHandler(new ScrollbarBundle.VisibilityHandler() {
                     @Override
         table.appendChild(footElem);
 
         Style hCornerStyle = headerDeco.getStyle();
-        hCornerStyle.setWidth(Util.getNativeScrollbarSize(), Unit.PX);
+        hCornerStyle.setWidth(WidgetUtil.getNativeScrollbarSize(), Unit.PX);
         hCornerStyle.setDisplay(Display.NONE);
         root.appendChild(headerDeco);
 
         Style fCornerStyle = footerDeco.getStyle();
-        fCornerStyle.setWidth(Util.getNativeScrollbarSize(), Unit.PX);
+        fCornerStyle.setWidth(WidgetUtil.getNativeScrollbarSize(), Unit.PX);
         fCornerStyle.setDisplay(Display.NONE);
         root.appendChild(footerDeco);
 
         Style hWrapperStyle = horizontalScrollbarDeco.getStyle();
         hWrapperStyle.setDisplay(Display.NONE);
-        hWrapperStyle.setHeight(Util.getNativeScrollbarSize(), Unit.PX);
+        hWrapperStyle.setHeight(WidgetUtil.getNativeScrollbarSize(), Unit.PX);
         root.appendChild(horizontalScrollbarDeco);
 
         setStylePrimaryName("v-escalator");
         }
 
         Profiler.enter("Escalator.recalculateElementSizes");
-        widthOfEscalator = Math.max(0,
-                Util.getRequiredWidthBoundingClientRectDouble(getElement()));
-        heightOfEscalator = Math.max(0,
-                Util.getRequiredHeightBoundingClientRectDouble(getElement()));
+        widthOfEscalator = Math.max(0, WidgetUtil
+                .getRequiredWidthBoundingClientRectDouble(getElement()));
+        heightOfEscalator = Math.max(0, WidgetUtil
+                .getRequiredHeightBoundingClientRectDouble(getElement()));
 
         header.recalculateSectionHeight();
         body.recalculateSectionHeight();
             @SuppressWarnings("deprecation")
             com.google.gwt.user.client.Element castElement = (com.google.gwt.user.client.Element) possibleWidgetNode
                     .cast();
-            Widget w = Util.findWidget(castElement, null);
+            Widget w = WidgetUtil.findWidget(castElement, null);
 
             // Ensure findWidget did not traverse past the cell element in the
             // DOM hierarchy
      * @return escalator's inner width
      */
     public double getInnerWidth() {
-        return Util.getRequiredWidthBoundingClientRectDouble(tableWrapper);
+        return WidgetUtil
+                .getRequiredWidthBoundingClientRectDouble(tableWrapper);
     }
 }

client/src/com/vaadin/client/widgets/Grid.java

 import com.google.gwt.user.client.ui.ResizeComposite;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.DeferredWorker;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.data.DataChangeHandler;
 import com.vaadin.client.data.DataSource;
 import com.vaadin.client.renderers.ComplexRenderer;
             int bodyTop = body.getElement().getAbsoluteTop();
             int wrapperTop = tableWrapper.getAbsoluteTop();
 
-            double width = Util.getRequiredWidthBoundingClientRectDouble(tr);
-            double height = Util.getRequiredHeightBoundingClientRectDouble(tr);
+            double width = WidgetUtil
+                    .getRequiredWidthBoundingClientRectDouble(tr);
+            double height = WidgetUtil
+                    .getRequiredHeightBoundingClientRectDouble(tr);
             setBounds(editorOverlay, tr.getOffsetLeft(), rowTop + bodyTop
                     - wrapperTop, width, height);
 
          */
         protected Element createCell(TableCellElement td) {
             DivElement cell = DivElement.as(DOM.createDiv());
-            double width = Util.getRequiredWidthBoundingClientRectDouble(td);
-            double height = Util.getRequiredHeightBoundingClientRectDouble(td);
+            double width = WidgetUtil
+                    .getRequiredWidthBoundingClientRectDouble(td);
+            double height = WidgetUtil
+                    .getRequiredHeightBoundingClientRectDouble(td);
             setBounds(cell, td.getOffsetLeft(), td.getOffsetTop(), width,
                     height);
             return cell;
                 Renderer renderer = findRenderer(cell);
                 if (renderer instanceof WidgetRenderer) {
                     try {
-                        Widget w = Util.findWidget(cell.getElement()
+                        Widget w = WidgetUtil.findWidget(cell.getElement()
                                 .getFirstChildElement(), Widget.class);
                         if (w != null) {
 
     }
 
     private boolean isElementInChildWidget(Element e) {
-        Widget w = Util.findWidget(e, null);
+        Widget w = WidgetUtil.findWidget(e, null);
 
         if (w == this) {
             return false;

uitest/src/com/vaadin/tests/widgetset/client/BasicExtensionTestConnector.java

 import com.google.gwt.dom.client.DivElement;
 import com.google.gwt.dom.client.Document;
 import com.vaadin.client.ServerConnector;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.extensions.AbstractExtensionConnector;
 import com.vaadin.shared.ui.Connect;
 import com.vaadin.tests.extensions.BasicExtension;
     }
 
     private void appendMessage(String action) {
-        String message = Util.getSimpleName(this) + action
-                + Util.getSimpleName(target);
+        String message = WidgetUtil.getSimpleName(this) + action
+                + WidgetUtil.getSimpleName(target);
 
         DivElement element = Document.get().createDivElement();
         element.setInnerText(message);

uitest/src/com/vaadin/tests/widgetset/client/CustomUIConnector.java

 
 import com.google.gwt.dom.client.Document;
 import com.google.gwt.dom.client.SpanElement;
-import com.vaadin.client.Util;
+import com.vaadin.client.WidgetUtil;
 import com.vaadin.client.ui.ui.UIConnector;
 import com.vaadin.shared.ui.Connect;
 import com.vaadin.ui.UI;
             public void test() {
                 SpanElement span = Document.get().createSpanElement();
                 span.setInnerText("This is the "
-                        + Util.getSimpleName(CustomUIConnector.this));
+                        + WidgetUtil.getSimpleName(CustomUIConnector.this));
                 Document.get().getBody().insertFirst(span);
             }
         });