Remove trailing whitespace from code and javadoc

Change-Id: I4c852b7f9928e190572876690d5bef1234494a5d

all/src/main/java/com/vaadin/buildhelpers/FetchReleaseNotesAuthors.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

buildhelpers/src/main/java/com/vaadin/buildhelpers/CompileTheme.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

buildhelpers/src/main/java/com/vaadin/buildhelpers/GeneratePackageExports.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * Export-Package attribute, and appends it to the jar's MANIFEST.MF.
  * <p>
  * See #3521 for details.
- * 
+ *
  * @author magi
  */
 public class GeneratePackageExports {
      * version.<java package>. Searches for the packge and then its parents
      * recursively. Falls back to the "vaadin.version" system property if no
      * other properties are found.
-     * 
+     *
      * @param javaPackage
      *            The package to determine a version for
      * @return A version or null if no version has been defined

buildhelpers/src/main/java/com/vaadin/buildhelpers/ManifestWriter.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Writes a manifest attribute to a temporary buffer.
-     * 
+     *
      * @param name
      *            Attribute name
      * @param value
 
     /**
      * Writes the manifest to given JAR file.
-     * 
+     *
      * The manifest must be created with {@code #writeAttribute(String, String)}
      * before calling this write.
-     * 
+     *
      * @param jarFilename
      *            File name of the JAR in which the manifest is written
      * @return 0 on success, nonzero value on error

checkstyle/header

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/sass/linker/SassLinker.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * Pre-linker that checks for the existence of SASS files in public folders,
  * compiles them to CSS files with the SassCompiler from Vaadin and adds the CSS
  * back into the artifact.
- * 
+ *
  */
 @LinkerOrder(Order.PRE)
 @Shardable
 
     /**
      * Writes the contents of an InputStream out to a file.
-     * 
+     *
      * @param contents
      * @param tempfile
      * @throws IOException
 
     /**
      * Create folder in temporary space on disk.
-     * 
+     *
      * @param partialPath
      * @return
      */

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/AcceptCriteriaFactoryGenerator.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * GWT generator to build {@link VAcceptCriterionFactory} implementation
  * dynamically based on {@link AcceptCriterion} annotations available in
  * classpath.
- * 
+ *
  */
 public class AcceptCriteriaFactoryGenerator extends Generator {
 
 
     /**
      * Generate source code for WidgetMapImpl
-     * 
+     *
      * @param logger
      *            Logger object
      * @param context

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/ArraySerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/ClientRpcVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/ConnectorInitVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/CustomSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/EnumSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/FieldProperty.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/GeneratedSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/JsonSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/MethodProperty.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Returns a list of all setters found in the beanType or its parent class
-     * 
+     *
      * @param beanType
      *            The type to check
      * @param getters

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/OnStateChangeVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Visits Connector classes and check for methods with @OnStateChange
  * annotations.
- * 
+ *
  * @since 7.2
  * @author Vaadin Ltd
  */

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/Property.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/RendererVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * {@link AbstractRendererConnector#decode(elemental.json.JsonValue) decode}
  * method to work without having to implement a "getPresentationType" method.
  * </ul>
- * 
+ *
  * @see WidgetInitVisitor
- * 
+ *
  * @since 7.4
  * @author Vaadin Ltd
  */

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/ServerRpcVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/StateInitVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/TypeVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/server/widgetsetutils/metadata/WidgetInitVisitor.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client-compiler/src/main/java/com/vaadin/tools/CvalAddonsChecker.java

 
     /**
      * Visit all MANIFEST.MF files in the classpath validating licenses.
-     * 
+     *
      * Return a list of Cval licensed products in order to have enough info to
      * generate nag messages in the UI.
      */
 
     /**
      * Set the filter regexp of .jar names which we have to consider.
-     * 
+     *
      * default is '.*touchkit.*'
      */
     public CvalAddonsChecker setFilter(String regexp) {

client-compiler/src/main/java/com/vaadin/tools/CvalChecker.java

 
     /*
      * Class used for binding the JSON gotten from server.
-     * 
+     *
      * It is not in a separate f le, so as it is easier to copy into any product
      * which does not depend on vaadin core.
-     * 
+     *
      * We are using elemental.json in order not to use additional dependency
      * like auto-beans, gson, etc.
      */

client-compiler/src/main/java/com/vaadin/tools/WidgetsetCompiler.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * A wrapper for the GWT compiler that runs the compiler in a new thread after
  * updating the widgetset file.
- * 
+ *
  * This class originally existed to allow circumventing a J2SE 5.0 bug (6316197)
  * that prevents setting the stack size for the main thread.
- * 
+ *
  * This class takes the same command line arguments as the
  * com.google.gwt.dev.Compiler class.
- * 
+ *
  * A typical invocation would use e.g. the following arguments
- * 
+ *
  * "-war WebContent/VAADIN/widgetsets com.vaadin.DefaultWidgetSet"
- * 
+ *
  * In addition, larger memory usage settings for the VM should be used, e.g.
- * 
+ *
  * "-Xms256M -Xmx512M -Xss8M"
- * 
+ *
  * The source directory containing widgetset and related classes must be
  * included in the classpath, as well as other relevant JARs.
- * 
+ *
  * @deprecated with Java 6, can use com.google.gwt.dev.Compiler directly (also
  *             in Eclipse plug-in etc.)
  */

client/src/main/java/com/vaadin/client/AnimationUtil.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Utility methods for working with CSS transitions and animations.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.3
  */
 
     /**
      * For internal use only. May be removed or replaced in the future.
-     * 
+     *
      * Set the animation-duration CSS property.
-     * 
+     *
      * @param elem
      *            the element whose animation-duration to set
      * @param duration
 
     /**
      * For internal use only. May be removed or replaced in the future.
-     * 
+     *
      * Set the animation-delay CSS property.
-     * 
+     *
      * @param elem
      *            the element whose animation-delay to set
      * @param delay
       var callbackFunc = $entry(function(e) {
         listener.@com.vaadin.client.AnimationUtil.AnimationEndListener::onAnimationEnd(Lcom/google/gwt/dom/client/NativeEvent;)(e);
       });
-    
+
       elem.addEventListener(@com.vaadin.client.AnimationUtil::ANIMATION_END_EVENT_NAME, callbackFunc, false);
-      
+
       // Store function reference for later removal
       if(!elem._vaadin_animationend_callbacks) {
         elem._vaadin_animationend_callbacks = [];
       }
       elem._vaadin_animationend_callbacks.push(callbackFunc);
-      
+
       return callbackFunc;
     }-*/;
 
             return event.mozAnimationName;
         else if(event.oAnimationName)
             return event.oAnimationName;
-    
+
         return "";
     }-*/;
 
     public static native String getAnimationName(ComputedStyle cstyle)
     /*-{
         var cs = cstyle.@com.vaadin.client.ComputedStyle::computedStyle;
-    
+
         if(!cs.getPropertyValue)
             return "";
-    
+
         if(cs.getPropertyValue("-webkit-animation-name"))
             return cs.getPropertyValue("-webkit-animation-name");
-    
+
         else if(cs.getPropertyValue("animation-name"))
             return cs.getPropertyValue("animation-name");
-    
+
         else if(cs.getPropertyValue("-moz-animation-name"))
             return cs.getPropertyValue("-moz-animation-name");
-    
+
         else if(cs.getPropertyValue("-o-animation-name"))
             return cs.getPropertyValue("-o-animation-name");
-    
+
         return "";
     }-*/;
 
           'MozAnimation': 'animationend',
           'WebkitAnimation': 'webkitAnimationEnd'
         }
-    
+
         for(var a in anims){
             if( el.style[a] !== undefined ){
                 return anims[a];
           'mozAnimation',
           'webkitAnimation'
         ]
-    
+
         for(var i=0; i < anims.length; i++) {
             if( el.style[anims[i]] !== undefined ){
                 return anims[i];

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     /**
      * Helper class for reading configuration options from the bootstap
      * javascript
-     * 
+     *
      * @since 7.0
      */
     private static class JsoConfiguration extends JavaScriptObject {
          * Reads a configuration parameter as a string. Please note that the
          * javascript value of the parameter should also be a string, or else an
          * undefined exception may be thrown.
-         * 
+         *
          * @param name
          *            name of the configuration parameter
          * @return value of the configuration parameter, or <code>null</code> if
          * Reads a configuration parameter as a boolean object. Please note that
          * the javascript value of the parameter should also be a boolean, or
          * else an undefined exception may be thrown.
-         * 
+         *
          * @param name
          *            name of the configuration parameter
          * @return boolean value of the configuration paramter, or
          * Reads a configuration parameter as an integer object. Please note
          * that the javascript value of the parameter should also be an integer,
          * or else an undefined exception may be thrown.
-         * 
+         *
          * @param name
          *            name of the configuration parameter
          * @return integer value of the configuration paramter, or
          * an object with appropriate fields, or else an undefined exception may
          * be thrown when calling this method or when calling methods on the
          * returned object.
-         * 
+         *
          * @param name
          *            name of the configuration parameter
          * @return error message with the given name, or <code>null</code> if no
         /**
          * Returns a native javascript object containing version information
          * from the server.
-         * 
+         *
          * @return a javascript object with the version information
          */
         private native JavaScriptObject getVersionInfoJSObject()
 
         /**
          * Gets the version of the Vaadin framework used on the server.
-         * 
+         *
          * @return a string with the version
-         * 
+         *
          * @see com.vaadin.server.VaadinServlet#VERSION
          */
         private native String getVaadinVersion()
 
         /**
          * Gets the version of the Atmosphere framework.
-         * 
+         *
          * @return a string with the version
-         * 
+         *
          * @see org.atmosphere.util#getRawVersion()
          */
         private native String getAtmosphereVersion()
 
         /**
          * Gets the JS version used in the Atmosphere framework.
-         * 
+         *
          * @return a string with the version
          */
         private native String getAtmosphereJSVersion()
 
     /**
      * Wraps a native javascript object containing fields for an error message
-     * 
+     *
      * @since 7.0
      */
     public static final class ErrorMessage extends JavaScriptObject {
      * Checks whether path info in requests to the server-side service should be
      * in a request parameter (named <code>v-resourcePath</code>) or appended to
      * the end of the service URL.
-     * 
+     *
      * @see #getServiceUrl()
-     * 
+     *
      * @return <code>true</code> if path info should be a request parameter;
      *         <code>false</code> if the path info goes after the service URL
      */
      * Return the name of the parameter used to to send data to the service url.
      * This method should only be called if {@link #useServiceUrlPathParam()} is
      * true.
-     * 
+     *
      * @since 7.1.6
      * @return The parameter name, by default <code>v-resourcePath</code>
      */
      * {@link #useServiceUrlPathParam()} return <code>true</code>, the requested
      * path info should be in the <code>v-resourcePath</code> query parameter;
      * else the path info should be appended to the end of the URL.
-     * 
+     *
      * @see #useServiceUrlPathParam()
-     * 
+     *
      * @return the URL to the server-side service as a string
      */
     public String getServiceUrl() {
 
     /**
      * Gets the URL of the VAADIN directory on the server.
-     * 
+     *
      * @return the URL of the VAADIN directory
      */
     public String getVaadinDirUrl() {
     /**
      * Gets the initial UIDL from the DOM, if it was provided during the init
      * process.
-     * 
+     *
      * @return
      */
     public String getUIDL() {
      * instance. The UI id should be included in every request originating from
      * this instance in order to associate the request with the right UI
      * instance on the server.
-     * 
+     *
      * @return the UI id
      */
     public int getUIId() {
     /**
      * Starts the application with a given id by reading the configuration
      * options stored by the bootstrap javascript.
-     * 
+     *
      * @param applicationId
      *            id of the application to load, this is also the id of the html
      *            element into which the application should be rendered.
     /**
      * Gets the configuration object for a specific application from the
      * bootstrap javascript.
-     * 
+     *
      * @param appId
      *            the id of the application to get configuration data for
      * @return a native javascript object containing the configuration data
 
     /**
      * Return Atmosphere version.
-     * 
+     *
      * @since 7.4
-     * 
+     *
      * @return Atmosphere version.
      */
     public String getAtmosphereVersion() {
 
     /**
      * Return Atmosphere JS version.
-     * 
+     *
      * @since 7.4
-     * 
+     *
      * @return Atmosphere JS version.
      */
     public String getAtmosphereJSVersion() {
      * Returns all tags for given class. Tags are used in
      * {@link ApplicationConfiguration} to keep track of different classes and
      * their hierarchy
-     * 
+     *
      * @since 7.2
      * @param classname
      *            name of class which tags we want
      * Registers that callback that the bootstrap javascript uses to start
      * applications once the widgetset is loaded and all required information is
      * available
-     * 
+     *
      * @param widgetsetName
      *            the name of this widgetset
      */
      * adding ?debug parameter to URI. Please note that debug mode is always
      * disabled if production mode is enabled, but disabling production mode
      * does not automatically enable debug mode.
-     * 
+     *
      * @see #isProductionMode()
-     * 
+     *
      * @return true if client side is currently been debugged
      */
     public static boolean isDebugMode() {
      * Checks if production mode is enabled. When production mode is enabled,
      * client-side logging is disabled. There may also be other performance
      * optimizations.
-     * 
+     *
      * @since 7.1.2
      * @return <code>true</code> if production mode is enabled; otherwise
      *         <code>false</code>.
 
     /**
      * Checks whether debug logging should be quiet
-     * 
+     *
      * @return <code>true</code> if debug logging should be quiet
      */
     public static boolean isQuietDebugMode() {
     /**
      * Checks whether the widget set version has been sent to the server. It is
      * sent in the first UIDL request.
-     * 
+     *
      * @return <code>true</code> if browser information has already been sent
      */
     public boolean isWidgetsetVersionSent() {

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

  * This is the client side communication "engine", managing client-server
  * communication with its server side counterpart
  * com.vaadin.server.VaadinService.
- * 
+ *
  * Client-side connectors receive updates from the corresponding server-side
  * connector (typically component) as state updates or RPC calls. The connector
  * has the possibility to communicate back with its server side counter part
  * through RPC calls.
- * 
+ *
  * TODO document better
- * 
+ *
  * Entry point classes (widgetsets) define <code>onModuleLoad()</code>.
  */
 public class ApplicationConnection implements HasHandlers {
      * A string that, if found in a non-JSON response to a UIDL request, will
      * cause the browser to refresh the page. If followed by a colon, optional
      * whitespace, and a URI, causes the browser to synchronously load the URI.
-     * 
+     *
      * <p>
      * This allows, for instance, a servlet filter to redirect the application
      * to a custom login page when the session expires. For example:
      * </p>
-     * 
+     *
      * <pre>
      * if (sessionExpired) {
      *     response.setHeader(&quot;Content-Type&quot;, &quot;text/html&quot;);
     /**
      * Event triggered when a application is stopped by calling
      * {@link ApplicationConnection#setApplicationRunning(false)}.
-     * 
+     *
      * To listen for the event add a {@link ApplicationStoppedHandler} by
      * invoking
      * {@link ApplicationConnection#addHandler(ApplicationConnection.ApplicationStoppedEvent.Type, ApplicationStoppedHandler)}
      * to the {@link ApplicationConnection}
-     * 
+     *
      * @since 7.1.8
      * @author Vaadin Ltd
      */
         /**
          * Called when a communication error has occurred. Returning
          * <code>true</code> from this method suppresses error handling.
-         * 
+         *
          * @param details
          *            A string describing the error.
          * @param statusCode
      * A listener for listening to application stopped events. The listener can
      * be added to a {@link ApplicationConnection} by invoking
      * {@link ApplicationConnection#addHandler(ApplicationStoppedEvent.Type, ApplicationStoppedHandler)}
-     * 
+     *
      * @since 7.1.8
      * @author Vaadin Ltd
      */
          * Triggered when the {@link ApplicationConnection} marks a previously
          * running application as stopped by invoking
          * {@link ApplicationConnection#setApplicationRunning(false)}
-         * 
+         *
          * @param event
          *            the event triggered by the {@link ApplicationConnection}
          */
      * called once this application has started (first response received) or
      * failed to start. This ensures that the applications are started in order,
      * to avoid session-id problems.
-     * 
+     *
      */
     public void start() {
         String jsonText = configuration.getUIDL();
 
     /**
      * Checks if there is some work to be done on the client side
-     * 
+     *
      * @return true if the client has some work to be done, false otherwise
      */
     private boolean isActive() {
                 return vi;
             }
         }
-    
+
         client.getProfilingData = $entry(function() {
             var smh = ap.@com.vaadin.client.ApplicationConnection::getMessageHandler()();
             var pd = [
             pd[pd.length] = smh.@com.vaadin.client.communication.MessageHandler::bootstrapTime;
             return pd;
         });
-    
+
         client.getElementByPath = $entry(function(id) {
             return componentLocator.@com.vaadin.client.componentlocator.ComponentLocator::getElementByPath(Ljava/lang/String;)(id);
         });
             return componentLocator.@com.vaadin.client.componentlocator.ComponentLocator::getPathForElement(Lcom/google/gwt/dom/client/Element;)(element);
         });
         client.initializing = false;
-    
+
         $wnd.vaadin.clients[TTAppId] = client;
     }-*/;
 
      * <li><code>vaadin.postRequestHooks</code> is a map of functions which gets
      * called after each XHR made by vaadin application. Note, that it is
      * attaching js functions responsibility to create the variable like this:
-     * 
+     *
      * <code><pre>
      * if(!vaadin.postRequestHooks) {vaadin.postRequestHooks = new Object();}
      * postRequestHooks.myHook = function(appId) {
      * </pre></code> First parameter passed to these functions is the identifier
      * of Vaadin application that made the request.
      * </ul>
-     * 
+     *
      * TODO make this multi-app aware
      */
     private native void initializeClientHooks()
     /**
      * Requests an analyze of layouts, to find inconsistencies. Exclusively used
      * for debugging during development.
-     * 
+     *
      * @deprecated as of 7.1. Replaced by {@link UIConnector#analyzeLayouts()}
      */
     @Deprecated
      * Sends a request to the server to print details to console that will help
      * the developer to locate the corresponding server-side connector in the
      * source code.
-     * 
+     *
      * @param serverConnector
      * @deprecated as of 7.1. Replaced by
      *             {@link UIConnector#showServerDebugInfo(ServerConnector)}
     /**
      * Checks whether or not the CSS is loaded. By default checks the size of
      * the loading indicator element.
-     * 
+     *
      * @return
      */
     protected boolean isCSSLoaded() {
 
     /**
      * Shows the communication error notification.
-     * 
+     *
      * @param details
      *            Optional details.
      * @param statusCode
      *            The status code returned for the request
-     * 
+     *
      */
     public void showCommunicationError(String details, int statusCode) {
         getLogger().severe("Communication error: " + details);
 
     /**
      * Shows the authentication error notification.
-     * 
+     *
      * @param details
      *            Optional details.
      */
 
     /**
      * Shows the session expiration notification.
-     * 
+     *
      * @param details
      *            Optional details.
      */
 
     /**
      * Shows an error notification.
-     * 
+     *
      * @param details
      *            Optional details.
      * @param message
      * <p>
      * Used by the native "client.isActive" function.
      * </p>
-     * 
+     *
      * @return true if deferred commands are (potentially) being executed, false
      *         otherwise
      */
 
     /**
      * Returns the loading indicator used by this ApplicationConnection
-     * 
+     *
      * @return The loading indicator for this ApplicationConnection
      */
     public VLoadingIndicator getLoadingIndicator() {
 
     /**
      * Determines whether or not the loading indicator is showing.
-     * 
+     *
      * @return true if the loading indicator is visible
      * @deprecated As of 7.1. Use {@link #getLoadingIndicator()} and
      *             {@link VLoadingIndicator#isVisible()}.isVisible() instead.
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * is true, the update is sent as soon as possible. If immediate is false,
      * the update will be sent along with the next immediate update.
      * </p>
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * the update will be sent along with the next immediate update.
      * <p>
      * A null array is sent as an empty array.
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
      * the update will be sent along with the next immediate update.
      * <p>
      * A null array is sent as an empty array.
-     * 
+     *
      * @param paintableId
      *            the id of the paintable that owns the variable
      * @param variableName
 
     /**
      * Does absolutely nothing. Replaced by {@link LayoutManager}.
-     * 
+     *
      * @param container
      * @deprecated As of 7.0, serves no purpose
      */
 
     /**
      * Returns false
-     * 
+     *
      * @param paintable
      * @return false, always
      * @deprecated As of 7.0, serves no purpose
 
     /**
      * Returns false
-     * 
+     *
      * @param paintable
      * @return false, always
      * @deprecated As of 7.0, serves no purpose
     /**
      * Get either an existing ComponentConnector or create a new
      * ComponentConnector with the given type and id.
-     * 
+     *
      * If a ComponentConnector with the given id already exists, returns it.
      * Otherwise creates and registers a new ComponentConnector of the given
      * type.
-     * 
+     *
      * @param connectorId
      *            Id of the paintable
      * @param connectorType
      *            Type of the connector, as passed from the server side
-     * 
+     *
      * @return Either an existing ComponentConnector or a new ComponentConnector
      *         of the given type
      */
 
     /**
      * Creates a new ServerConnector with the given type and id.
-     * 
+     *
      * Creates and registers a new ServerConnector of the given type. Should
      * never be called with the connector id of an existing connector.
-     * 
+     *
      * @param connectorId
      *            Id of the new connector
      * @param connectorType
      *            Type of the connector, as passed from the server side
-     * 
+     *
      * @return A new ServerConnector of the given type
      */
     private ServerConnector createAndRegisterConnector(String connectorId,
     /**
      * Gets a resource that has been pre-loaded via UIDL, such as custom
      * layouts.
-     * 
+     *
      * @param name
      *            identifier of the resource to get
      * @return the resource
     /**
      * Sets a resource that has been pre-loaded via UIDL, such as custom
      * layouts.
-     * 
+     *
      * @since 7.6
      * @param name
      *            identifier of the resource to Set
 
     /**
      * Singleton method to get instance of app's context menu.
-     * 
+     *
      * @return VContextMenu object
      */
     public VContextMenu getContextMenu() {
 
     /**
      * Gets an {@link Icon} instance corresponding to a URI.
-     * 
+     *
      * @since 7.2
      * @param uri
      * @return Icon object
      * Translates custom protocols in UIDL URI's to be recognizable by browser.
      * All uri's from UIDL should be routed via this method before giving them
      * to browser due URI's in UIDL may contain custom protocols like theme://.
-     * 
+     *
      * @param uidlUri
      *            Vaadin URI from uidl
      * @return translated URI ready for browser
     /**
      * Gets the URI for the current theme. Can be used to reference theme
      * resources.
-     * 
+     *
      * @return URI to the current theme
      */
     public String getThemeUri() {
     /**
      * Use to notify that the given component's caption has changed; layouts may
      * have to be recalculated.
-     * 
+     *
      * @param component
      *            the Paintable whose caption has changed
      * @deprecated As of 7.0.2, has not had any effect for a long time
 
     /**
      * Gets the main view
-     * 
+     *
      * @return the main view
      */
     public UIConnector getUIConnector() {
 
     /**
      * Gets the {@link ApplicationConfiguration} for the current application.
-     * 
+     *
      * @see ApplicationConfiguration
      * @return the configuration for this application
      */
      * list of events which has server side listeners is updated automatically
      * before the component is updated so the value is correct if called from
      * updatedFromUIDL.
-     * 
+     *
      * @param connector
      *            The connector to register event listeners for
      * @param eventIdentifier
     /**
      * Adds the get parameters to the uri and returns the new uri that contains
      * the parameters.
-     * 
+     *
      * @param uri
      *            The uri to which the parameters should be added.
      * @param extraParams
 
     /**
      * Get VTooltip instance related to application connection
-     * 
+     *
      * @return VTooltip instance
      */
     public VTooltip getVTooltip() {
      * this method is now handled by the state change event handler in
      * AbstractComponentConnector. The only function this method has is to
      * return true if the UIDL is a "cached" update.
-     * 
+     *
      * @param component
      * @param uidl
      * @param manageCaption
      * Schedules a heartbeat request to occur after the configured heartbeat
      * interval elapses if the interval is a positive number. Otherwise, does
      * nothing.
-     * 
+     *
      * @deprecated as of 7.2, use {@link Heartbeat#schedule()} instead
      */
     @Deprecated
      * Heartbeat requests are used to inform the server that the client-side is
      * still alive. If the client page is closed or the connection lost, the
      * server will eventually close the inactive UI.
-     * 
+     *
      * @deprecated as of 7.2, use {@link Heartbeat#send()} instead
      */
     @Deprecated
 
     /**
      * Sets the delegate that is called whenever a communication error occurrs.
-     * 
+     *
      * @param delegate
      *            the delegate.
      */
     /**
      * Checks if the application is in the {@link ApplicationState#RUNNING}
      * state.
-     * 
+     *
      * @since 7.6
      * @return true if the application is in the running state, false otherwise
      */
 
     /**
      * Gets the active connector for focused element in browser.
-     * 
+     *
      * @return Connector for focused element or null.
      */
     private ComponentConnector getActiveConnector() {
      * "initializing" to "running" to "stopped". There is no way for an
      * application to go back to a previous state, i.e. a stopped application
      * can never be re-started
-     * 
+     *
      * @since 7.6
      * @return the current state of this application
      */
 
     /**
      * Gets the server RPC queue for this application
-     * 
+     *
      * @since 7.6
      * @return the server RPC queue
      */
 
     /**
      * Gets the communication error handler for this application
-     * 
+     *
      * @since 7.6
      * @return the server RPC queue
      */
 
     /**
      * Gets the (server to client) message handler for this application
-     * 
+     *
      * @since 7.6
      * @return the message handler
      */
 
     /**
      * Gets the server rpc manager for this application
-     * 
+     *
      * @since 7.6
      * @return the server rpc manager
      */
 
     /**
      * Gets the (client to server) message sender for this application
-     * 
+     *
      * @since 7.6
      * @return the message sender
      */

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Class used to query information about web browser.
- * 
+ *
  * Browser details are detected only once and those are stored in this singleton
  * class.
- * 
+ *
  */
 public class BrowserInfo {
 
 
     /**
      * Singleton method to get BrowserInfo object.
-     * 
+     *
      * @return instance of BrowserInfo object
      */
     public static BrowserInfo get() {
      * Returns a string representing the browser in use, for use in CSS
      * classnames. The classnames will be space separated abbreviations,
      * optionally with a version appended.
-     * 
+     *
      * Abbreviations: Firefox: ff Internet Explorer: ie Safari: sa Opera: op
-     * 
+     *
      * Browsers that CSS-wise behave like each other will get the same
      * abbreviation (this usually depends on the rendering engine).
-     * 
+     *
      * This is quite simple at the moment, more heuristics will be added when
      * needed.
-     * 
+     *
      * Examples: Internet Explorer 6: ".v-ie .v-ie6 .v-ie60", Firefox 3.0.4:
      * ".v-ff .v-ff3 .v-ff30", Opera 9.60: ".v-op .v-op9 .v-op960", Opera 10.10:
      * ".v-op .v-op10 .v-op1010"
-     * 
+     *
      * @return
      */
     public String getCSSClass() {
     /**
      * Returns the Gecko version if the browser is Gecko based. The Gecko
      * version for Firefox 2 is 1.8 and 1.9 for Firefox 3.
-     * 
+     *
      * @return The Gecko version or -1 if the browser is not Gecko based
      */
     public float getGeckoVersion() {
     /**
      * Returns the WebKit version if the browser is WebKit based. The WebKit
      * version returned is the major version e.g., 523.
-     * 
+     *
      * @return The WebKit version or -1 if the browser is not WebKit based
      */
     public float getWebkitVersion() {
     /**
      * Indicates whether the browser might require juggling to properly update
      * sizes inside elements with overflow: auto.
-     * 
+     *
      * @return <code>true</code> if the browser requires the workaround,
      *         otherwise <code>false</code>
      */
      * <p>
      * See https://bugs.webkit.org/show_bug.cgi?id=123958 and
      * http://code.google.com/p/chromium/issues/detail?id=316549
-     * 
+     *
      * @since 7.1.8
      * @return <code>true</code> if the browser requires the workaround,
      *         otherwise <code>false</code>
 
     /**
      * Checks if the browser is run on iOS
-     * 
+     *
      * @return true if the browser is run on iOS, false otherwise
      */
     public boolean isIOS() {
 
     /**
      * Checks if the browser is run on iOS 6.
-     * 
+     *
      * @since 7.1.1
      * @return true if the browser is run on iOS 6, false otherwise
      */
 
     /**
      * Checks if the browser is run on Android
-     * 
+     *
      * @return true if the browser is run on Android, false otherwise
      */
     public boolean isAndroid() {
     /**
      * Checks if the browser is capable of handling scrolling natively or if a
      * touch scroll helper is needed for scrolling.
-     * 
+     *
      * @return true if browser needs a touch scroll helper, false if the browser
      *         can handle scrolling natively
      */
     /**
      * Tests if this is an Android devices with a broken scrollTop
      * implementation
-     * 
+     *
      * @return true if scrollTop cannot be trusted on this device, false
      *         otherwise
      */
      * Note that Internet Explorer 8 and newer will return the document mode so
      * IE8 rendering as IE7 will return 7.
      * </p>
-     * 
+     *
      * @return The major version of the browser.
      */
     public int getBrowserMajorVersion() {
 
     /**
      * Returns the browser minor version e.g., 5 for Firefox 3.5.
-     * 
+     *
      * @see #getBrowserMajorVersion()
-     * 
+     *
      * @return The minor version of the browser, or -1 if not known/parsed.
      */
     public int getBrowserMinorVersion() {
     /**
      * Checks if the browser version is newer or equal to the given major+minor
      * version.
-     * 
+     *
      * @param majorVersion
      *            The major version to check for
      * @param minorVersion

client/src/main/java/com/vaadin/client/CSSRule.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     private JavaScriptObject rules = null;
 
     /**
-     * 
+     *
      * @param selector
      *            the CSS selector to search for in the stylesheets
      * @param deep
     /*-{
     if(!$doc.styleSheets)
     return null;
-    
+
     selector = selector.toLowerCase();
-    
+
     var allMatches = [];
-    
+
     // IE handles imported sheet differently
     if(deep && sheet.imports && sheet.imports.length > 0) {
     for(var i=0; i < sheet.imports.length; i++) {
     allMatches.concat(imports);
     }
     }
-    
+
     var theRules = new Array();
     if (sheet.cssRules)
     theRules = sheet.cssRules
     else if (sheet.rules)
     theRules = sheet.rules
-    
+
     var j = theRules.length;
     for(var i=0; i<j; i++) {
     var r = theRules[i];
     allMatches = allMatches.concat(imports);
     }
     }
-    
+
     return allMatches;
     }-*/;
 
     /**
      * Returns a specific property value from this CSS rule.
-     * 
+     *
      * @param propertyName
      *            camelCase CSS property name
      * @return the value of the property as a String

client/src/main/java/com/vaadin/client/ComponentConnector.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * An interface used by client-side widgets or paintable parts to receive
  * updates from the corresponding server-side components in the form of
  * {@link UIDL}.
- * 
+ *
  * Updates can be sent back to the server using the
  * {@link ApplicationConnection#updateVariable()} methods.
  */
 
     /*
      * (non-Javadoc)
-     * 
+     *
      * @see com.vaadin.client.VPaintable#getState()
      */
     @Override
      * Returns <code>true</code> if the width of this paintable is currently
      * undefined. If the width is undefined, the actual width of the paintable
      * is defined by its contents.
-     * 
+     *
      * @return <code>true</code> if the width is undefined, else
      *         <code>false</code>
      */
      * Returns <code>true</code> if the height of this paintable is currently
      * undefined. If the height is undefined, the actual height of the paintable
      * is defined by its contents.
-     * 
+     *
      * @return <code>true</code> if the height is undefined, else
      *         <code>false</code>
      */
      * Returns <code>true</code> if the width of this paintable is currently
      * relative. If the width is relative, the actual width of the paintable is
      * a percentage of the size allocated to it by its parent.
-     * 
+     *
      * @return <code>true</code> if the width is undefined, else
      *         <code>false</code>
      */
      * Returns <code>true</code> if the height of this paintable is currently
      * relative. If the height is relative, the actual height of the paintable
      * is a percentage of the size allocated to it by its parent.
-     * 
+     *
      * @return <code>true</code> if the width is undefined, else
      *         <code>false</code>
      */
 
     /**
      * Checks if the connector is read only.
-     * 
+     *
      * @deprecated This belongs in AbstractFieldConnector, see #8514
      * @return true
      */
     /**
      * Return true if parent handles caption, false if the paintable handles the
      * caption itself.
-     * 
+     *
      * <p>
      * This should always return true and all components should let the parent
      * handle the caption and use other attributes for internal texts in the
      * component
      * </p>
-     * 
+     *
      * @return true if caption handling is delegated to the parent, false if
      *         parent should not be allowed to render caption
      */
 
     /**
      * Sets the enabled state of the widget associated to this connector.
-     * 
+     *
      * @param widgetEnabled
      *            true if the widget should be enabled, false otherwise
      */
      * overridden to return <code>true</code> in all situations where this
      * method might return a non-empty result.
      * </p>
-     * 
+     *
      * @param element
      *            The element to lookup a tooltip for
      * @return The tooltip for the element or null if no tooltip is defined for
      * This is only done to optimize performance, so in cases where the status
      * is not known, it's safer to return <code>true</code> so that there will
      * be a tooltip handler even though it might not be needed in all cases.
-     * 
+     *
      * @return <code>true</code> if some part of the component might have a
      *         tooltip, otherwise <code>false</code>
      */

client/src/main/java/com/vaadin/client/ComponentDetail.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     /**
      * Returns a TooltipInfo assosiated with Component. If element is given,
      * returns an additional TooltipInfo.
-     * 
+     *
      * @param key
      * @return the tooltipInfo
      */

client/src/main/java/com/vaadin/client/ComponentDetailMap.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/ComputedStyle.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
      * <p>
      * Note that this method is expensive. Wherever possible, reuse the returned
      * object.
-     * 
+     *
      * @param elem
      *            the element
      * @return the computed style
       if(elem.nodeType != 1) {
           return {};
       }
-      
+
       if($wnd.document.defaultView && $wnd.document.defaultView.getComputedStyle) {
           return $wnd.document.defaultView.getComputedStyle(elem, null);
       }
-      
+
       if(elem.currentStyle) {
           return elem.currentStyle;
       }
     }-*/;
 
     /**
-     * 
+     *
      * @param name
      *            name of the CSS property in camelCase
      * @return the value of the property, normalized for across browsers (each
     /*-{
         var cs = this.@com.vaadin.client.ComputedStyle::computedStyle;
         var elem = this.@com.vaadin.client.ComputedStyle::elem;
-        
+
         // Border values need to be checked separately. The width might have a 
         // meaningful value even if the border style is "none". In that case the 
         // value should be 0.
             if(borderStyle == "none")
                 return "0px";
         }
-    
+
         if(cs.getPropertyValue) {
-        
+
             // Convert name to dashed format
             name = name.replace(/([A-Z])/g, "-$1").toLowerCase();
             var ret = cs.getPropertyValue(name);
-            
+
         } else {
-        
+
             var ret = cs[name];
             var style = elem.style;
-    
+
             // From the awesome hack by Dean Edwards
             // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
-    
+
             // If we're not dealing with a regular pixel number
             // but a number that has a weird ending, we need to convert it to pixels
                 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
                     // Remember the original values
                     var left = style.left, rsLeft = elem.runtimeStyle.left;
-    
+
                     // Put in the new values to get a computed value out
                     elem.runtimeStyle.left = cs.left;
                     style.left = ret || 0;
                     ret = style.pixelLeft + "px";
-    
+
                     // Revert the changed values
                     style.left = left;
                     elem.runtimeStyle.left = rsLeft;
                 }
-            
+
         }
-        
+
         // Normalize margin values. This is not totally valid, but in most cases 
         // it is what the user wants to know.
         if(name.indexOf("margin") > -1 && ret == "auto") {
             return "0px";
         }
-        
+
         // Some browsers return undefined width and height values as "auto", so
         // we need to retrieve those ourselves.
         if (name == "width" && ret == "auto") {
         } else if (name == "height" && ret == "auto") {
             ret = elem.clientHeight + "px";
         }
-    
+
         return ret;
-        
+
     }-*/;
 
     /**
      * Retrieves the given computed property as an integer
-     * 
+     *
      * Returns 0 if the property cannot be converted to an integer
-     * 
+     *
      * @param name
      *            the property to retrieve
      * @return the integer value of the property or 0
 
     /**
      * Retrieves the given computed property as a double
-     * 
+     *
      * Returns NaN if the property cannot be converted to a double
-     * 
+     *
      * @since 7.5.1
      * @param name
      *            the property to retrieve
 
     /**
      * Returns the current width from the DOM.
-     * 
+     *
      * @since 7.5.1
      * @return the computed width
      */
 
     /**
      * Returns the current height from the DOM.
-     * 
+     *
      * @since 7.5.1
      * @return the computed height
      */
 
     /**
      * Takes a String value e.g. "12px" and parses that to Integer 12.
-     * 
+     *
      * @param String
      *            a value starting with a number
      * @return Integer the value from the string before any non-numeric
      *         characters. If the value cannot be parsed to a number, returns
      *         <code>null</code>.
-     * 
+     *
      * @deprecated Since 7.1.4, the method {@link #parseIntNative(String)} is
      *             used internally and this method does not belong in the public
      *             API of {@link ComputedStyle}. {@link #parseInt(String)} might
 
     /**
      * Takes a String value e.g. "12px" and parses that to int 12.
-     * 
+     *
      * <p>
      * This method returns 0 for <code>NaN</code>.
-     * 
+     *
      * @param String
      *            a value starting with a number
      * @return int the value from the string before any non-numeric characters.
 
     /**
      * Takes a String value e.g. "12.3px" and parses that to a double, 12.3.
-     * 
+     *
      * @param String
      *            a value starting with a number
      * @return the value from the string before any non-numeric characters or
 
     /**
      * Returns the sum of the top and bottom border width
-     * 
+     *
      * @since 7.5.3
      * @return the sum of the top and bottom border
      */
 
     /**
      * Returns the sum of the left and right border width
-     * 
+     *
      * @since 7.5.3
      * @return the sum of the left and right border
      */
 
     /**
      * Returns the sum of the top and bottom padding
-     * 
+     *
      * @since 7.5.3
      * @return the sum of the top and bottom padding
      */
 
     /**
      * Returns the sum of the top and bottom padding
-     * 
+     *
      * @since 7.5.3
      * @return the sum of the left and right padding
      */
 
     /**
      * Returns the sum of the top and bottom margin
-     * 
+     *
      * @since 7.5.6
      * @return the sum of the top and bottom margin
      */
 
     /**
      * Returns the sum of the top and bottom margin
-     * 
+     *
      * @since 7.5.6
      * @return the sum of the left and right margin
      */

client/src/main/java/com/vaadin/client/ConnectorHierarchyChangeEvent.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * hierarchy. A {@link ConnectorHierarchyChangedEvent} is fired when an update
  * from the server has been fully processed and all hierarchy updates have been
  * completed.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
- * 
+ *
  */
 public class ConnectorHierarchyChangeEvent
         extends AbstractServerConnectorEvent<ConnectorHierarchyChangeHandler> {
     /**
      * Returns a collection of the old children for the connector. This was the
      * state before the update was received from the server.
-     * 
+     *
      * @return A collection of old child connectors. Never returns null.
      */
     public List<ComponentConnector> getOldChildren() {
 
     /**
      * Sets the collection of the old children for the connector.
-     * 
+     *
      * @param oldChildren
      *            The old child connectors. Must not be null.
      */
 
     /**
      * Returns the {@link HasComponentsConnector} for which this event occurred.
-     * 
+     *
      * @return The {@link HasComponentsConnector} whose child collection has
      *         changed. Never returns null.
      */
          * parent connector might not yet have detached a child widget and that
          * the widget of a removed child might already have been attached by its
          * new parent.
-         * 
+         *
          * @param connectorHierarchyChangeEvent
          *            the event with information about the hierarchy change
          */

client/src/main/java/com/vaadin/client/ConnectorMap.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Returns a {@link ServerConnector} by its id
-     * 
+     *
      * @param id
      *            The connector id
      * @return A connector or null if a connector with the given id has not been
 
     /**
      * Returns a {@link ComponentConnector} element by its root element.
-     * 
+     *
      * @param element
      *            Root element of the {@link ComponentConnector}
      * @return A connector or null if a connector with the given id has not been
 
     /**
      * FIXME: What does this even do and why?
-     * 
+     *
      * @param pid
      * @return
      */
 
     /**
      * Checks if a connector with the given id has been registered.
-     * 
+     *
      * @param connectorId
      *            The id to check for
      * @return true if a connector has been registered with the given id, false
 
     /**
      * Retrieves the connector whose widget matches the parameter.
-     * 
+     *
      * @param widget
      *            The widget
      * @return A connector with {@literal widget} as its root widget or null if
      * Gets the connector id using a DOM element - the element should be the
      * root element for a connector, otherwise no id will be found. Use
      * {@link #getConnectorId(ServerConnector)} instead whenever possible.
-     * 
+     *
      * @see #getConnectorId(ServerConnector)
      * @param el
      *            element of the connector whose id is desired
     /**
      * Gets the main element for the connector with the given id. The reverse of
      * {@link #getConnectorId(Element)}.
-     * 
+     *
      * @param connectorId
      *            the id of the widget whose element is desired
      * @return the element for the connector corresponding to the id
      * This method does not remove the connector from the DOM, but marks the
      * connector so that ApplicationConnection may clean up its references to
      * it. Removing the widget from DOM is component containers responsibility.
-     * 
+     *
      * @param connector
      *            the connector to remove
      */
 
     /**
      * Gets all registered {@link ComponentConnector} instances
-     * 
+     *
      * @return An array of all registered {@link ComponentConnector} instances
-     * 
+     *
      * @deprecated As of 7.0.1, use {@link #getComponentConnectorsAsJsArray()}
      *             for better performance.
      */
 
     /**
      * @return
-     * 
+     *
      * @deprecated As of 7.0.1, use {@link #getConnectorsAsJsArray()} for
      *             improved performance.
      */
 
     /**
      * Tests if the widget is the root widget of a {@link ComponentConnector}.
-     * 
+     *
      * @param widget
      *            The widget to test
      * @return true if the widget is the root widget of a

client/src/main/java/com/vaadin/client/ContainerResizedListener.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * ContainerResizedListener interface is useful for Widgets that support
  * relative sizes and who need some additional sizing logic.
- * 
+ *
  * @deprecated As of 7.0, serves no purpose. Use {@link LayoutManager} and its
  *             methods instead.
  */
      * function on its ancestors that implement NeedsLayout in case their
      * container has resized. runAnchestorsLayout(HasWidgets parent) function
      * from Util class may be a good helper for this.
-     * 
+     *
      * @deprecated As of 7.0, this method is never called by the framework.
-     * 
+     *
      */
     @Deprecated
     public void iLayout();

client/src/main/java/com/vaadin/client/DateTimeService.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * This class provides date/time parsing services to all components on the
  * client side.
- * 
+ *
  * @author Vaadin Ltd.
- * 
+ *
  */
 @SuppressWarnings("deprecation")
 public class DateTimeService {
 
     /**
      * Creates a new date time service with a given locale.
-     * 
+     *
      * @param locale
      *            e.g. fi, en etc.
      * @throws LocaleNotLoadedException
 
     /**
      * Returns the ISO-8601 week number of the given date.
-     * 
+     *
      * @param date
      *            The date for which the week number should be resolved
      * @return The ISO-8601 week number for {@literal date}
      * it to the month name since DateTimeFormat.format always uses the current
      * locale and will replace the month name wrong if current locale is
      * different from the locale set for the DateField.
-     * 
+     *
      * MMMM is converted into long month name, MMM is converted into short month
      * name. '' are added around the name to avoid that DateTimeFormat parses
      * the month name as a pattern.
-     * 
+     *
      * @param date
      *            The date to convert
      * @param formatStr
     /**
      * Replaces month names in the entered date with the name in the current
      * browser locale.
-     * 
+     *
      * @param enteredDate
      *            Date string e.g. "5 May 2010"
      * @param formatString
     /**
      * Parses the given date string using the given format string and the locale
      * set in this DateTimeService instance.
-     * 
+     *
      * @param dateString
      *            Date string e.g. "1 February 2010"
      * @param formatString
      * @return A Date object representing the dateString. Never returns null.
      * @throws IllegalArgumentException
      *             if the parsing fails
-     * 
+     *
      */
     public Date parseDate(String dateString, String formatString,
             boolean lenient) throws IllegalArgumentException {

client/src/main/java/com/vaadin/client/DeferredWorker.java

  * there is work scheduled to be executed in the near future and that the
  * framework should wait for this work to complete before assuming the UI has
  * reached a steady state.
- * 
+ *
  * @since 7.3
  * @author Vaadin Ltd
  */
     /**
      * Checks whether there are operations pending for this widget or connector
      * that must be executed before reaching a steady state.
-     * 
+     *
      * @returns <code>true</code> iff there are operations pending which must be
      *          executed before reaching a steady state
      */

client/src/main/java/com/vaadin/client/DirectionalManagedLayout.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/EventHelper.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * registration (possibly the same as given, should be store for next update.
  * <p>
  * Pseudocode what helpers do:
- * 
+ *
  * <pre>
- * 
+ *
  * if paintable has event listener in UIDL
  *      if registration is null
  *              register paintable as as handler for event
  *      if registration is not null
  *              remove the handler from paintable
  *      return null
- * 
- * 
+ *
+ *
  * </pre>
  */
 public class EventHelper {
     /**
      * Adds or removes a focus handler depending on if the connector has focus
      * listeners on the server side or not.
-     * 
+     *
      * @param connector
      *            The connector to update. Must implement focusHandler.
      * @param handlerRegistration
     /**
      * Adds or removes a focus handler depending on if the connector has focus
      * listeners on the server side or not.
-     * 
+     *
      * @param connector
      *            The connector to update. Must implement focusHandler.
      * @param handlerRegistration
     /**
      * Adds or removes a blur handler depending on if the connector has blur
      * listeners on the server side or not.
-     * 
+     *
      * @param connector
      *            The connector to update. Must implement BlurHandler.
      * @param handlerRegistration
     /**
      * Adds or removes a blur handler depending on if the connector has blur
      * listeners on the server side or not.
-     * 
+     *
      * @param connector
      *            The connector to update. Must implement BlurHandler.
      * @param handlerRegistration
      *            registered previously
      * @param widget
      *            The widget which emits blur events
-     * 
+     *
      * @return a new registration handler that can be used to unregister the
      *         handler later
      */

client/src/main/java/com/vaadin/client/FastStringMap.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/FastStringSet.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/Focusable.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * GWT's HasFocus is way too overkill for just receiving focus in simple
  * components. Vaadin uses this interface in addition to GWT's HasFocus to pass
  * focus requests from server to actual ui widgets in browsers.
- * 
+ *
  * So in to make your server side focusable component receive focus on client
  * side it must either implement this or HasFocus interface.
  */

client/src/main/java/com/vaadin/client/HasChildMeasurementHintConnector.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Connector with layout measuring hint. Used to improve granularity of control
  * over child component measurements.
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */
 
     /**
      * Sets the child measurement hint for this component.
-     * 
+     *
      * @param hint
      *            the value to set
      */
 
     /**
      * Returns the current child measurement hint value.
-     * 
+     *
      * @return a ChildLayoutMeasureMode value
      */
     ChildMeasurementHint getChildMeasurementHint();

client/src/main/java/com/vaadin/client/HasComponentsConnector.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Update child components caption, description and error message.
-     * 
+     *
      * <p>
      * Each component is responsible for maintaining its caption, description
      * and error message. In most cases components doesn't want to do that and
      * those elements reside outside of the component. Because of this layouts
      * must provide service for it's childen to show those elements for them.
      * </p>
-     * 
+     *
      * @param connector
      *            Child component for which service is requested.
      */
      * Note that the method {@link ServerConnector#getChildren()} can return a
      * larger list of children including both the child components and any
      * extensions registered for the connector.
-     * 
+     *
      * @return A collection of child components for this connector. An empty
      *         collection if there are no children. Never returns null.
      */
      * {@link ServerConnector#setChildren(List)} and contains only child
      * components. Both methods are called separately by the framework if the
      * connector implements {@link HasComponentsConnector}.
-     * 
+     *
      * @param children
      *            The new child connectors (components only)
      */
     /**
      * Adds a handler that is called whenever the child hierarchy of this
      * connector has been updated by the server.
-     * 
+     *
      * @param handler
      *            The handler that should be added.
      * @return A handler registration reference that can be used to unregister

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
      * javascript is usually initalized the first time a state change event is
      * received, but it might in some cases be necessary to make this happen
      * earlier.
-     * 
+     *
      * @since 7.4.0
      */
     public void ensureJavascriptInited() {
                 delete state[key];
             }
         }
-        
+
         for(var key in input) {
             if (input.hasOwnProperty(key)) {
                 state[key] = input[key];

client/src/main/java/com/vaadin/client/JavaScriptExtension.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/JsArrayObject.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Returns the application connection for this layout manager.
-     * 
+     *
      * @return connection
      */
     protected ApplicationConnection getConnection() {
     /**
      * Gets the layout manager associated with the given
      * {@link ApplicationConnection}.
-     * 
+     *
      * @param connection
      *            the application connection to get a layout manager for
      * @return the layout manager associated with the provided application
      * This causes this layout manager to measure the element in the beginning
      * of every layout phase and call the appropriate layout method of the
      * managed layout if the size of the element has changed.
-     * 
+     *
      * @param owner
      *            the ManagedLayout that depends on an element
      * @param element
     /**
      * Assigns a measured size to an element. Method defined as protected to
      * allow separate implementation for IE8.
-     * 
+     *
      * @param element
      *            the dom element to attach the measured size to
      * @param measuredSize
     /**
      * Gets the measured size for an element. Method defined as protected to
      * allow separate implementation for IE8.
-     * 
+     *
      * @param element
      *            The element to get measured size for
      * @param defaultSize
     /**
      * Registers that a ManagedLayout is no longer depending on the size of an
      * Element.
-     * 
+     *
      * @see #registerDependency(ManagedLayout, Element)
-     * 
+     *
      * @param owner
      *            the ManagedLayout no longer depends on an element
      * @param element
      * to explicitly cause some layout to be considered in an ongoing layout
      * phase, you should use {@link #setNeedsMeasure(ComponentConnector)}
      * instead.
-     * 
+     *
      * @param layout
      *            the managed layout that should be layouted
      */
      * to explicitly cause some layout to be considered in an ongoing layout
      * phase, you should use {@link #setNeedsMeasure(ComponentConnector)}
      * instead.
-     * 
+     *
      * @param layout
      *            the managed layout that should be layouted
      */
      * to explicitly cause some layout to be considered in an ongoing layout
      * phase, you should use {@link #setNeedsMeasure(ComponentConnector)}
      * instead.
-     * 
+     *
      * @param layout
      *            the managed layout that should be layouted
      */
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
      * <p>
      * The value returned by this method is always rounded up. To get the exact
      * outer width, use {@link #getOuterHeightDouble(Element)}
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured outer height (including margins, paddings and
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            the element to get the measured size for
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
      * <p>
      * The value returned by this method is always rounded up. To get the exact
      * outer width, use {@link #getOuterWidthDouble(Element)}
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            the element to get the measured size for
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured outer width (including margins, paddings and
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
      * <p>
      * The value returned by this method is always rounded up. To get the exact
      * outer width, use {@link #getInnerHeightDouble(Element)}
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured inner height (excluding margins, paddings and
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            the element to get the measured size for
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
      * <p>
      * The value returned by this method is always rounded up. To get the exact
      * outer width, use {@link #getOuterHeightDouble(Element)}
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured inner width (excluding margins, paddings and
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * -1 is returned if the element has not been measured. If 0 is returned, it
      * might indicate that the element is not attached to the DOM.
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            the element to get the measured size for
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured border height (top border + bottom border) of the
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured padding height (top padding + bottom padding) of the
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured border width (left border + right border) of the
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured top border of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured left border of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured bottom border of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured right border of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured padding width (left padding + right padding) of the
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured top padding of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured left padding of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured bottom padding of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured right padding of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured top margin of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured right margin of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured bottom margin of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured size for
      * @return the measured left margin of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured margin for
      * @return the measured top+bottom margin of the element in pixels.
      * <li>Elements for which at least one ManagedLayout has registered a
      * dependency
      * </ul>
-     * 
+     *
      * A negative number is returned if the element has not been measured. If 0
      * is returned, it might indicate that the element is not attached to the
      * DOM.
-     * 
+     *
      * @param element
      *            the element to get the measured margin for
      * @return the measured left+right margin of the element in pixels.
      * informing the LayoutManager about what size a component will have, the
      * layout propagation can continue directly without first measuring the
      * potentially resized elements.
-     * 
+     *
      * @param component
      *            the component for which the size is reported
      * @param outerHeight
      * LayoutManager about what size a component will have, the layout
      * propagation can continue directly without first measuring the potentially
      * resized elements.
-     * 
+     *
      * @param component
      *            the relatively sized component for which the size is reported
      * @param assignedHeight
      * LayoutManager about what size a component will have, the layout
      * propagation can continue directly without first measuring the potentially
      * resized elements.
-     * 
+     *
      * @param component
      *            the relatively sized component for which the size is reported
      * @param assignedWidth
      * informing the LayoutManager about what size a component will have, the
      * layout propagation can continue directly without first measuring the
      * potentially resized elements.
-     * 
+     *
      * @param component
      *            the component for which the size is reported
      * @param outerWidth
      * element changes. Adding a listener to an element also ensures that all
      * sizes for that element will be available starting from the next layout
      * phase.
-     * 
+     *
      * @param element
      *            the element that should be checked for size changes
      * @param listener
      * Removes an element resize listener from the provided element. This might
      * cause this LayoutManager to stop tracking the size of the element if no
      * other sources are interested in the size.
-     * 
+     *
      * @param element
      *            the element to which the element resize listener was
      *            previously added
      * {@link #setNeedsMeasureRecursively(ComponentConnector)} instead.
      * <p>
      * If there is no upcoming layout phase, a new layout phase is scheduled.
-     * 
+     *
      * @param component
      *            the component whose size might have changed.
      */
      * {@link #setNeedsMeasure(ComponentConnector)} instead.
      * <p>
      * If there is no upcoming layout phase, a new layout phase is scheduled.
-     * 
+     *
      * @since 7.2
      * @param component
      *            the component at the root of the component hierarchy to
 
     /**
      * Checks if there is something waiting for a layout to take place.
-     * 
+     *
      * @since 7.5.6
      * @return true if there are connectors waiting for measurement or layout,
      *         false otherwise

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * element in IE8 seems to make the browser think the element has changed in a
  * way that requires a reflow. To work around that, the MeasureData is instead
  * stored in Map for IE8.
- * 
+ *
  * This implementation is injected for IE8 by a replace-with definition in the
  * GWT module.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
  */

client/src/main/java/com/vaadin/client/LocaleNotLoadedException.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/LocaleService.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Date / time etc. localisation service for all widgets. Caches all loaded
  * locales as JSONObjects.
- * 
+ *
  * @author Vaadin Ltd.
- * 
+ *
  */
 public class LocaleService {
 

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Helper class for constructing a MouseEventDetails object from a
  * {@link NativeEvent}.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
- * 
+ *
  */
 public class MouseEventDetailsBuilder {
 
     /**
      * Construct a {@link MouseEventDetails} object from the given event
-     * 
+     *
      * @param evt
      *            The event to use as a source for the details
      * @return a MouseEventDetails containing information from the event
 
     /**
      * Construct a {@link MouseEventDetails} object from the given event
-     * 
+     *
      * @param evt
      *            The event to use as a source for the details
      * @param relativeToElement

client/src/main/java/com/vaadin/client/Paintable.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * An interface used by client-side widgets or paintable parts to receive
  * updates from the corresponding server-side components in the form of
  * {@link UIDL}.
- * 
+ *
  * Updates can be sent back to the server using the
  * {@link ApplicationConnection#updateVariable()} methods.
  */

client/src/main/java/com/vaadin/client/Profiler.java

      * Interface for getting data from the {@link Profiler}.
      * <p>
      * <b>Warning!</b> This interface is most likely to change in the future
-     * 
+     *
      * @since 7.1
      * @author Vaadin Ltd
      */
 
         /**
          * Create a new node with the given name.
-         * 
+         *
          * @param name
          */
         public Node(String name) {
 
         /**
          * Gets the name of the node
-         * 
+         *
          * @return the name of the node
          */
         public String getName() {
         /**
          * Creates a new child node or retrieves and existing child and updates
          * its total time and hit count.
-         * 
+         *
          * @param name
          *            the name of the child
          * @param timestamp
         /**
          * Gets the total time spent in this node, including time spent in sub
          * nodes
-         * 
+         *
          * @return the total time spent, in milliseconds
          */
         public double getTimeSpent() {
         /**
          * Gets the minimum time spent for one invocation of this node,
          * including time spent in sub nodes
-         * 
+         *
          * @return the time spent for the fastest invocation, in milliseconds
          */
         public double getMinTimeSpent() {
         /**
          * Gets the maximum time spent for one invocation of this node,
          * including time spent in sub nodes
-         * 
+         *
          * @return the time spent for the slowest invocation, in milliseconds
          */
         public double getMaxTimeSpent() {
 
         /**
          * Gets the number of times this node has been entered
-         * 
+         *
          * @return the number of times the node has been entered
          */
         public int getCount() {
         /**
          * Gets the total time spent in this node, excluding time spent in sub
          * nodes
-         * 
+         *
          * @return the total time spent, in milliseconds
          */
         public double getOwnTime() {
 
         /**
          * Gets the child nodes of this node
-         * 
+         *
          * @return a collection of child nodes
          */
         public Collection<Node> getChildren() {
      * Returns time relative to the particular page load time. The value should
      * not be used directly but rather difference between two values returned by
      * this method should be used to compare measurements.
-     * 
+     *
      * @since 7.6
      */
     public static double getRelativeTimeMillis() {

client/src/main/java/com/vaadin/client/RenderInformation.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Contains size information about a rendered container and its content area.
- * 
+ *
  * @author Artur Signell
- * 
+ *
  */
 public class RenderInformation {
 
 
     /**
      * Update the size of the widget.
-     * 
+     *
      * @param widget
-     * 
+     *
      * @return true if the size has changed since last update
      * @deprecated As of 7.2, call and override {@link #updateSize(Element)}
      *             instead
 
     /**
      * Update the size of the widget.
-     * 
+     *
      * @param widget
-     * 
+     *
      * @return true if the size has changed since last update
-     * 
+     *
      * @since 7.2
      */
     public boolean updateSize(Element element) {

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * ResourceLoader lets you dynamically include external scripts and styles on
  * the page and lets you know when the resource has been loaded.
- * 
+ *
  * You can also preload resources, allowing them to get cached by the browser
  * without being evaluated. This enables downloading multiple resources at once
  * while still controlling in which order e.g. scripts are executed.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
  */
 
         /**
          * Creates a new event.
-         * 
+         *
          * @param loader
          *            the resource loader that has loaded the resource
          * @param resourceUrl
 
         /**
          * Gets the resource loader that has fired this event
-         * 
+         *
          * @return the resource loader
          */
         public ResourceLoader getResourceLoader() {
 
         /**
          * Gets the absolute url of the loaded resource.
-         * 
+         *
          * @return the absolute url of the loaded resource
          */
         public String getResourceUrl() {
         /**
          * Returns true if the resource has been preloaded, false if it's fully
          * loaded
-         * 
+         *
          * @see ResourceLoader#preloadResource(String, ResourceLoadListener)
-         * 
+         *
          * @return true if the resource has been preloaded, false if it's fully
          *         loaded
          */
          * Notifies this ResourceLoadListener that a resource has been loaded.
          * Some browsers do not support any way of detecting load errors. In
          * these cases, onLoad will be called regardless of the status.
-         * 
+         *
          * @see ResourceLoadEvent
-         * 
+         *
          * @param event
          *            a resource load event with information about the loaded
          *            resource
          * server did not respond. Some browsers do not support any way of
          * detecting load errors. In these cases, onLoad will be called
          * regardless of the status.
-         * 
+         *
          * @see ResourceLoadEvent
-         * 
+         *
          * @param event
          *            a resource load event with information about the resource
          *            that could not be loaded.
 
     /**
      * Returns the default ResourceLoader
-     * 
+     *
      * @return the default ResourceLoader
      */
     public static ResourceLoader get() {
      * this method when the script is currently loading or already loaded
      * doesn't cause the script to be loaded again, but the listener will still
      * be notified when appropriate.
-     * 
-     * 
+     *
+     *
      * @param scriptUrl
      *            the url of the script to load
      * @param resourceLoadListener
      * this method when the script is currently loading or already loaded
      * doesn't cause the script to be loaded again, but the listener will still
      * be notified when appropriate.
-     * 
-     * 
+     *
+     *
      * @param scriptUrl
      *            url of script to load
      * @param resourceLoadListener
     /**
      * The current browser supports script.async='false' for maintaining
      * execution order for dynamically-added scripts.
-     * 
+     *
      * @return Browser supports script.async='false'
      * @since 7.2.4
      */
      * preloaded, it will be present in the browser's cache (provided the HTTP
      * headers allow caching), making a subsequent load operation complete
      * without having to wait for the resource to be downloaded again.
-     * 
+     *
      * Calling this method when the resource is currently loading, currently
      * preloading, already preloaded or already loaded doesn't cause the
      * resource to be preloaded again, but the listener will still be notified
      * when appropriate.
-     * 
+     *
      * @param url
      *            the url of the resource to preload
      * @param resourceLoadListener
      * Adds an onload listener to the given element, which should be a link or a
      * script tag. The listener is called whenever loading is complete or an
      * error occurred.
-     * 
+     *
      * @since 7.3
      * @param element
      *            the element to attach a listener to
      * Calling this method when the stylesheet is currently loading or already
      * loaded doesn't cause the stylesheet to be loaded again, but the listener
      * will still be notified when appropriate.
-     * 
+     *
      * @param stylesheetUrl
      *            the url of the stylesheet to load
      * @param resourceLoadListener
                     if (rules === undefined) {
                         rules = sheet.rules;
                     }
-    
+
                     if (rules === null) {
                         // Style sheet loaded, but can't access length because of XSS -> assume there's something there
                         return 1;
                     }
-    
+
                     // Return length so we can distinguish 0 (probably 404 error) from normal case.
                     return rules.length;
                 } catch (err) {

client/src/main/java/com/vaadin/client/ServerConnector.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * Interface implemented by all client side classes that can be communicate with
  * the server. Classes implementing this interface are initialized by the
  * framework when needed and have the ability to communicate with the server.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
  */
 
     /**
      * Gets ApplicationConnection instance that created this connector.
-     * 
+     *
      * @return The ApplicationConnection as set by
      *         {@link #doInit(String, ApplicationConnection)}
      */
      * Tests whether the connector is enabled or not. This method checks that
      * the connector is enabled in context, i.e. if the parent connector is
      * disabled, this method must return false.
-     * 
+     *
      * @return true if the connector is enabled, false otherwise
      */
     public boolean isEnabled();
 
     /**
-     * 
+     *
      * Called once by the framework to initialize the connector.
      * <p>
      * Note that the shared state is not yet available at this point nor any
     /**
      * For internal use by the framework: returns the registered RPC
      * implementations for an RPC interface identifier.
-     * 
+     *
      * TODO interface identifier type or format may change
-     * 
+     *
      * @param rpcInterfaceId
      *            RPC interface identifier: fully qualified interface type name
      * @return RPC interface implementations registered for an RPC interface,
     /**
      * Adds a handler that is called whenever any part of the state has been
      * updated by the server.
-     * 
+     *
      * @param handler
      *            The handler that should be added.
      * @return A handler registration reference that can be used to unregister
     /**
      * Removes a handler that is called whenever any part of the state has been
      * updated by the server.
-     * 
+     *
      * @param handler
      *            The handler that should be removed.
      */
     /**
      * Adds a handler that is called whenever the given part of the state has
      * been updated by the server.
-     * 
+     *
      * @param propertyName
      *            the name of the property for which the handler should be
      *            called
     /**
      * Removes a handler that is called whenever any part of the state has been
      * updated by the server.
-     * 
+     *
      * @param propertyName
      *            the name of the property for which the handler should be
      *            called
 
     /**
      * Sends the given event to all registered handlers.
-     * 
+     *
      * @param event
      *            The event to send.
      */
     /**
      * Returns the parent of this connector. Can be null for only the root
      * connector.
-     * 
+     *
      * @return The parent of this connector, as set by
      *         {@link #setParent(ServerConnector)}.
      */
      * Note that calling this method does not fire a
      * {@link ConnectorHierarchyChangeEvent}. The event is fired only when the
      * whole hierarchy has been updated.
-     * 
+     *
      * @param parent
      *            The new parent of the connector
      */
      * {@link HasComponentsConnector#setChildComponents(List)} and takes both
      * extensions and child components. Both methods are called separately by
      * the framework if the connector can have child components.
-     * 
+     *
      * @param children
      *            The new child connectors (extensions and/or components)
      */
      * Note that the method {@link HasComponentsConnector#getChildComponents()}
      * can be used to obtain the subset of child connectors that correspond to
      * components and not extensions.
-     * 
+     *
      * @return A collection of child connectors (components or extensions) for
      *         this connector. An empty collection if there are no children.
      *         Never returns null.
 
     /**
      * Gets the current shared state of the connector.
-     * 
+     *
      * Note that state is considered an internal part of the connector. You
      * should not rely on the state object outside of the connector who owns it.
      * If you depend on the state of other connectors you should use their
      * public API instead of their state object directly.
-     * 
+     *
      * @since 7.0.
      * @return state The shared state object. Can be any sub type of
      *         {@link SharedState}. Never null.
     /**
      * Checks if an event listener has been registered on the server side for
      * the given event identifier.
-     * 
+     *
      * @param eventIdentifier
      *            The identifier for the event
      * @return true if a listener has been registered on the server side, false

client/src/main/java/com/vaadin/client/SimpleTree.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * @author Vaadin Ltd
- * 
+ *
  * @deprecated as of 7.1. This class was mainly used by the old debug console
  *             but is retained for now for backwards compatibility.
  */
 
     /**
      * {@inheritDoc}
-     * 
+     *
      * @deprecated As of 7.2, call and override {@link #add(Widget, Element)}
      *             instead.
      */
 
     /**
      * {@inheritDoc}
-     * 
+     *
      * @since 7.2
      */
     @Override

client/src/main/java/com/vaadin/client/StyleConstants.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Class that enables SuperDevMode using a ?superdevmode parameter in the url.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0
- * 
+ *
  */
 public class SuperDevMode {
 
     private native static String getRecompileParameters(String moduleName)
     /*-{
         var prop_map = $wnd.__gwt_activeModules[moduleName].bindings();
-        
+
         // convert map to URL parameter string
         var props = [];
         for (var key in prop_map) {
            props.push(encodeURIComponent(key) + '=' + encodeURIComponent(prop_map[key]))
         }
-        
+
         return props.join('&') + '&';
     }-*/;
 
     /**
      * The URL of the code server. The default URL (http://localhost:9876/) will
      * be used if this is empty or null.
-     * 
+     *
      * @param serverUrl
      *            The url of the code server or null to use the default
      * @return true if recompile started, false if we are running in
         var mod = $wnd.__gwt_activeModules[moduleName];
         if (!mod)
             return false;
-    
+
         if (mod.superdevmode) {
            // Running in super dev mode already, it is supported
            return true;
         }
-    
+
         return !!mod.canRedirect;
     }-*/;
 
      * method returns true. The application will be restarted once compilation
      * is done and then this method will return false.
      * </p>
-     * 
+     *
      * @return true if a recompile operation has started and the page will be
      *         reloaded once it is done, false if no recompilation will be done.
      */

client/src/main/java/com/vaadin/client/TooltipInfo.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Checks is a message has been defined for the tooltip.
-     * 
+     *
      * @return true if title or error message is present, false if both are
      *         empty
      */

client/src/main/java/com/vaadin/client/UIDL.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
      * Shorthand for getting the attribute named "id", which for Paintables is
      * the essential paintableId which binds the server side component to the
      * client side widget.
-     * 
+     *
      * @return the value of the id attribute, if available
      */
     public String getId() {
      * internally and is not needed within
      * {@link ComponentConnector#updateFromUIDL(UIDL, ApplicationConnection)
      * updateFromUIDL()}.
-     * 
+     *
      * @return the name for this section
      */
     public native String getTag()
 
     /**
      * Gets the named attribute as a String.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the names of the attributes available.
-     * 
+     *
      * @return the names of available attributes
      */
     public Set<String> getAttributeNames() {
 
     /**
      * Gets the names of variables available.
-     * 
+     *
      * @return the names of available variables
      */
     public Set<String> getVariableNames() {
 
     /**
      * Gets the named attribute as an int.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as a long.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as a float.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as a double.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as a boolean.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as a Map of named values (key/value pairs).
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute Map
 
     /**
      * Gets the named attribute as an array of Strings.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Gets the named attribute as an int array.
-     * 
+     *
      * @param name
      *            the name of the attribute to get
      * @return the attribute value
 
     /**
      * Get attributes value as string whatever the type is
-     * 
+     *
      * @param name
      * @return string presentation of attribute
      */
 
     /**
      * Indicates whether or not the named attribute is available.
-     * 
+     *
      * @param name
      *            the name of the attribute to check
      * @return true if the attribute is available, false otherwise
 
     /**
      * Gets the UIDL for the child at the given index.
-     * 
+     *
      * @param i
      *            the index of the child to get
      * @return the UIDL of the child if it exists
 
     /**
      * Gets the child at the given index as a String.
-     * 
+     *
      * @param i
      *            the index of the child to get
      * @return the String representation of the child if it exists
      * if <code>getTag()</code> returns "color", one would update the widgets
      * color to reflect the value of the "color" section.
      * </p>
-     * 
+     *
      * @return an iterator for iterating over UIDL children
      */
     public Iterator<Object> getChildIterator() {
 
     /**
      * Checks if the named variable is available.
-     * 
+     *
      * @param name
      *            the name of the variable desired
      * @return true if the variable exists, false otherwise
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named String[] variable as a Set of Strings.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Gets the value of the named variable.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the value of the variable
 
     /**
      * Returns the number of children.
-     * 
+     *
      * @return the number of children
      */
     public native int getChildCount()
 
     /**
      * Gets the Paintable with the id found in the named attributes's value.
-     * 
+     *
      * @param name
      *            the name of the attribute
      * @return the Paintable referenced by the attribute, if it exists
 
     /**
      * Gets the Paintable with the id found in the named variable's value.
-     * 
+     *
      * @param name
      *            the name of the variable
      * @return the Paintable referenced by the variable, if it exists
     /**
      * Returns the child UIDL by its name. If several child nodes exist with the
      * given name, the first child UIDL will be returned.
-     * 
+     *
      * @param tagName
      * @return the child UIDL or null if child wit given name was not found
      */

client/src/main/java/com/vaadin/client/Util.java

 
     /**
      * Helper method for debugging purposes.
-     * 
+     *
      * Stops execution on firefox browsers on a breakpoint.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#browserDebugger()}
      *             instead.
      */
      * Helper method for a bug fix #14041. For mozilla getKeyCode return 0 for
      * space bar (because space is considered as char). If return 0 use
      * getCharCode.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#getKeyCode(KeyEvent)}
      *             instead.
-     * 
+     *
      * @param event
      * @return return key code
      * @since 7.2.4
     }
 
     /**
-     * 
+     *
      * Returns the topmost element of from given coordinates.
-     * 
+     *
      * TODO fix crossplat issues clientX vs pageX. See quircksmode. Not critical
      * for vaadin as we scroll div istead of page.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getElementFromPoint(int, int)} instead.
-     * 
+     *
      * @param x
      * @param y
      * @return the element at given coordinates
      * This helper method can be called if components size have been changed
      * outside rendering phase. It notifies components parent about the size
      * change so it can react.
-     * 
+     *
      * When using this method, developer should consider if size changes could
      * be notified lazily. If lazy flag is true, method will save widget and
      * wait for a moment until it notifies parents in chunks. This may vastly
      * optimize layout in various situation. Example: if component have a lot of
      * images their onload events may fire "layout phase" many times in a short
      * period.
-     * 
+     *
      * @param widget
      * @param lazy
      *            run componentSizeUpdated lazyly
-     * 
+     *
      * @deprecated As of 7.0, use
      *             {@link LayoutManager#setNeedsMeasure(ComponentConnector)}
      *             instead
 
     /**
      * Converts html entities to text.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#escapeHTML(String)}
      *             instead.
-     * 
+     *
      * @param html
      * @return escaped string presentation of given html
      */
 
     /**
      * Escapes the string so it is safe to write inside an HTML attribute.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#escapeAttribute(String)}
      *             instead.
-     * 
+     *
      * @param attribute
      *            The string to escape
      * @return An escaped version of <literal>attribute</literal>.
 
     /**
      * Clones given element as in JavaScript.
-     * 
+     *
      * Deprecate this if there appears similar method into GWT someday.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#cloneNode(Element, boolean)} instead.
-     * 
+     *
      * @param element
      * @param deep
      *            clone child tree also
 
     /**
      * Defers the execution of {@link #runWebkitOverflowAutoFix(Element)}
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#runWebkitOverflowAutoFixDeferred(Element)}
      *             instead.
-     * 
+     *
      * @since 7.2.6
      * @param elem
      *            with overflow auto
 
     /**
      * Run workaround for webkits overflow auto issue.
-     * 
+     *
      * See: our bug #2138 and https://bugs.webkit.org/show_bug.cgi?id=21462
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#runWebkitOverflowAutoFix(Element)} instead.
-     * 
+     *
      * @param elem
      *            with overflow auto
      */
      * dimension is not specified as relative it will return -1. If the shared
      * state does not contain width or height specifications this will return
      * null.
-     * 
+     *
      * @param state
      * @return
      */
      * Checks if a and b are equals using {@link #equals(Object)}. Handles null
      * values as well. Does not ensure that objects are of the same type.
      * Assumes that the first object's equals method handle equals properly.
-     * 
+     *
      * @param a
      *            The first value to compare
      * @param b
     /**
      * Gets the border-box width for the given element, i.e. element width +
      * border + padding. Always rounds up to nearest integer.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#getRequiredWidth(Element)}
      *             instead.
-     * 
+     *
      * @param element
      *            The element to check
      * @return The border-box width for the element
     /**
      * Gets the border-box height for the given element, i.e. element height +
      * border + padding. Always rounds up to nearest integer.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getRequiredHeight(Element)} instead.
-     * 
+     *
      * @param element
      *            The element to check
      * @return The border-box height for the element
 
     /**
      * Detects what is currently the overflow style attribute in given element.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#mayHaveScrollBars(Element)} instead.
-     * 
+     *
      * @param pe
      *            the element to detect
      * @return true if auto or scroll
      * also returned if "element" is part of its caption. If
      * <literal>element</literal> is not part of any child component, null is
      * returned.
-     * 
+     *
      * This method returns the deepest nested VPaintableWidget.
-     * 
+     *
      * @param client
      *            A reference to ApplicationConnection
      * @param parent
 
     /**
      * Will (attempt) to focus the given DOM Element.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#focus(Element)} instead.
-     * 
+     *
      * @param el
      *            the element to focus
      */
     /**
      * Helper method to find the nearest parent paintable instance by traversing
      * the DOM upwards from given element.
-     * 
+     *
      * @param element
      *            the element to start from
      */
     /**
      * Helper method to find first instance of given Widget type found by
      * traversing DOM upwards from given element.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#findWidget(Element, Class)} instead.
-     * 
+     *
      * @param element
      *            the element where to start seeking of Widget
      * @param class1
 
     /**
      * Force webkit to redraw an element
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#forceWebkitRedraw(Element)} instead.
-     * 
+     *
      * @param element
      *            The element that should be redrawn
      */
      * Performs a hack to trigger a re-layout in the IE8. This is usually
      * necessary in cases where IE8 "forgets" to update child elements when they
      * resize.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#forceIE8Redraw(Element)}
      *             instead.
-     * 
+     *
      * @param e
      *            The element to perform the hack on
      */
      * Performs a hack to trigger a re-layout in the IE browser. This is usually
      * necessary in cases where IE "forgets" to update child elements when they
      * resize.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#forceIERedraw(Element)}
      *             instead.
-     * 
+     *
      * @since 7.3
      * @param e
      *            The element to perform the hack on
     /**
      * Detaches and re-attaches the element from its parent. The element is
      * reattached at the same position in the DOM as it was before.
-     * 
+     *
      * Does nothing if the element is not attached to the DOM.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#detachAttach(Element)}
      *             instead.
-     * 
+     *
      * @param element
      *            The element to detach and re-attach
      */
 
     /**
      * Returns the index of the childElement within its parent.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getChildElementIndex(Element)} instead.
-     * 
+     *
      * @param subElement
      * @return
      */
     /**
      * Produces a string representation of a method invocation, suitable for
      * debug output
-     * 
+     *
      * @since 7.5
      * @param invocation
      * @return
      * Temporarily sets the {@code styleProperty} to {@code tempValue} and then
      * resets it to its current value. Used mainly to work around rendering
      * issues in IE (and possibly in other browsers)
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#setStyleTemporarily(Element, String, String)}
      *             instead.
-     * 
+     *
      * @param element
      *            The target element
      * @param styleProperty
      * A helper method to return the client position from an event. Returns
      * position from either first changed touch (if touch event) or from the
      * event itself.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getTouchOrMouseClientX(Event)} instead.
-     * 
+     *
      * @param event
      * @return
      */
      * Find the element corresponding to the coordinates in the passed mouse
      * event. Please note that this is not always the same as the target of the
      * event e.g. if event capture is used.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getElementUnderMouse(NativeEvent)} instead.
-     * 
+     *
      * @param event
      *            the mouse event to get coordinates from
      * @return the element at the coordinates of the event
      * A helper method to return the client position from an event. Returns
      * position from either first changed touch (if touch event) or from the
      * event itself.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getTouchOrMouseClientY(Event)} instead.
-     * 
+     *
      * @param event
      * @return
      */
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getTouchOrMouseClientY(NativeEvent)}
      *             instead.
-     * 
+     *
      * @see #getTouchOrMouseClientY(Event)
      * @param currentGwtEvent
      * @return
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#getTouchOrMouseClientX(NativeEvent)}
      *             instead.
-     * 
+     *
      * @see #getTouchOrMouseClientX(Event)
-     * 
+     *
      * @param event
      * @return
      */
 
     /**
      * Gets the currently focused element.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#getFocusedElement()}
      *             instead.
-     * 
+     *
      * @return The active element or null if no active element could be found.
      */
     @Deprecated
 
     /**
      * Gets the currently focused element for Internet Explorer.
-     * 
+     *
      * @return The currently focused element
      * @deprecated Use #getFocusedElement instead
      */
 
     /**
      * Gets currently focused element and checks if it's editable
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#isFocusedElementEditable()} instead.
-     * 
+     *
      * @since 7.4
-     * 
+     *
      * @return true if focused element is editable
      */
     @Deprecated
      * this method checks that this widget nor any of its parents is hidden. Can
      * be e.g used to check whether component should react to some events or
      * not.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#isAttachedAndDisplayed(Widget)} instead.
-     * 
+     *
      * @param widget
      * @return true if attached and displayed
      */
     /**
      * Scrolls an element into view vertically only. Modified version of
      * Element.scrollIntoView.
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#scrollIntoViewVertically(Element)} instead.
-     * 
+     *
      * @param elem
      *            The element to scroll into view
      */
     /**
      * Checks if the given event is either a touch event or caused by the left
      * mouse button
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#isTouchEventOrLeftMouseButton(Event)}
      *             instead.
-     * 
+     *
      * @param event
      * @return true if the event is a touch event or caused by the left mouse
      *         button, false otherwise
 
     /**
      * Performs a shallow comparison of the collections.
-     * 
+     *
      * @param collection1
      *            The first collection
      * @param collection2
     /**
      * Resolve a relative URL to an absolute URL based on the current document's
      * location.
-     * 
+     *
      * @deprecated As of 7.4.0, use {@link WidgetUtil#getAbsoluteUrl(String)}
      *             instead.
-     * 
+     *
      * @param url
      *            a string with the relative URL to resolve
      * @return the corresponding absolute URL as a string
 
     /**
      * Sets the selection range of an input element.
-     * 
+     *
      * We need this JSNI function to set selection range so that we can use the
      * optional direction attribute to set the anchor to the end and the focus
      * to the start. This makes Firefox work the same way as other browsers
      * (#13477)
-     * 
+     *
      * @deprecated As of 7.4.0, use
      *             {@link WidgetUtil#setSelectionRange(Element, int, int, String)}
      *             instead.
-     * 
+     *
      * @param elem
      *            the html input element.
      * @param pos
      *            a string indicating the direction in which the selection was
      *            performed. This may be "forward" or "backward", or "none" if
      *            the direction is unknown or irrelevant.
-     * 
+     *
      * @since 7.3
      */
     @Deprecated
      * Converts a native {@link JavaScriptObject} into a {@link JsonValue}. This
      * is a no-op in GWT code compiled to javascript, but needs some special
      * handling to work when run in JVM.
-     * 
+     *
      * @param jso
      *            the java script object to represent as json
      * @return the json representation
      * Converts a {@link JsonValue} into a native {@link JavaScriptObject}. This
      * is a no-op in GWT code compiled to javascript, but needs some special
      * handling to work when run in JVM.
-     * 
+     *
      * @param jsonValue
      *            the json value
      * @return a native javascript object representation of the json value
 
     /**
      * Convert a {@link JavaScriptObject} into a string representation.
-     * 
+     *
      * @param json
      *            a JavaScript object to be converted to a string
      * @return JSON in string representation
 
     /**
      * Parse a string containing JSON into a {@link JavaScriptObject}.
-     * 
+     *
      * @param <T>
      *            the overlay type to expect from the parse
      * @param jsonAsString
 
     /**
      * Round {@code num} up to {@code exp} decimal positions.
-     * 
+     *
      * @since 7.6
      */
     public static native double round(double num, int exp)
      * appropriate mode set.
      *
      * This version of the method tries to recursively locate such a parent.
-     * 
+     *
      * For internal use only. May be removed or replaced in the future.
      */
     public static boolean shouldSkipMeasurementOfConnector(

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Creates a caption that is not linked to a {@link ComponentConnector}.
-     * 
+     *
      * When using this constructor, {@link #getOwner()} returns null.
-     * 
+     *
      * @param client
      *            ApplicationConnection
      * @deprecated all captions should be associated with a paintable widget and
 
     /**
      * Creates a caption for a {@link ComponentConnector}.
-     * 
+     *
      * @param component
      *            owner of caption, not null
      * @param client
 
     /**
      * Updates the caption from UIDL.
-     * 
+     *
      * This method may only be called when the caption has an owner - otherwise,
      * use {@link #updateCaptionWithoutOwner(UIDL, String, boolean, boolean)}.
-     * 
+     *
      * @return true if the position where the caption should be placed has
      *         changed
      */
     /**
      * Checks whether anything in a given state change might cause the caption
      * to change.
-     * 
+     *
      * @param event
      *            the state change event to check
      * @return <code>true</code> if the caption might have changed; otherwise
 
     /**
      * Returns Paintable for which this Caption belongs to.
-     * 
+     *
      * @return owner Widget
      */
     public ComponentConnector getOwner() {
 
     /**
      * Sets the tooltip that should be shown for the caption
-     * 
+     *
      * @param tooltipInfo
      *            The tooltip that should be shown or null if no tooltip should
      *            be shown
 
     /**
      * Returns the tooltip that should be shown for the caption
-     * 
+     *
      * @return The tooltip to show or null if no tooltip should be shown
      */
     public TooltipInfo getTooltipInfo() {
      * Sets whether the caption is rendered as HTML.
      * <p>
      * Default is false
-     * 
+     *
      * @param captionAsHtml
      *            true if the captions are rendered as HTML, false if rendered
      *            as plain text
      * Checks whether captions are rendered as HTML.
      * <p>
      * Default is false
-     * 
+     *
      * @return true if the captions are rendered as HTML, false if rendered as
      *         plain text
      */
      * <p>
      * Uses {@link AbstractComponentState#captionAsHtml} to determine whether to
      * set the caption as html or plain text
-     * 
+     *
      * @since 7.4
      * @param captionElement
      *            the target element
      * <p>
      * Uses {@link AbstractComponentState#captionAsHtml} to determine whether to
      * set the caption as html or plain text
-     * 
+     *
      * @since 7.4
      * @param widget
      *            the target widget

client/src/main/java/com/vaadin/client/VCaptionWrapper.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Creates a new caption wrapper panel.
-     * 
+     *
      * @param toBeWrapped
      *            paintable that the caption is associated with, not null
      * @param client

client/src/main/java/com/vaadin/client/VConsole.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * A helper class to do some client side logging.
- * 
+ *
  * @deprecated as of 7.1, use {@link Logger} from java.util.logging instead.
  */
 @Deprecated
 
     /**
      * Used by ApplicationConfiguration to initialize VConsole.
-     * 
+     *
      * @param console
      */
     static void setImplementation(VDebugWindow console) {

client/src/main/java/com/vaadin/client/VErrorMessage.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
      * The owner must be set if the {@link VErrorMessage} is created
      * 'stand-alone' (not within a {@link VOverlay}), or theming might not work
      * properly.
-     * 
+     *
      * @see VOverlay#setOwner(Widget)
      * @param owner
      *            the owner (creator Widget)
 
     /**
      * Shows this error message next to given element.
-     * 
+     *
      * @param indicatorElement
      * @deprecated As of 7.2, call and override {@link #showAt(Element)} instead
      */
 
     /**
      * Shows this error message next to given element.
-     * 
+     *
      * @param indicatorElement
-     * 
+     *
      * @since 7.2
      */
     public void showAt(Element indicatorElement) {

client/src/main/java/com/vaadin/client/VLoadingIndicator.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * {@link #trigger()} is called the indicator moves to its "triggered" state and
  * then transitions from one state to the next when the timeouts specified using
  * the set*StateDelay methods occur.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.1
  */
     /**
      * Returns the delay (in ms) which must pass before the loading indicator
      * moves into the "first" state and is shown to the user
-     * 
+     *
      * @return The delay (in ms) until moving into the "first" state. Counted
      *         from when {@link #trigger()} is called.
      */
     /**
      * Sets the delay (in ms) which must pass before the loading indicator moves
      * into the "first" state and is shown to the user
-     * 
+     *
      * @param firstDelay
      *            The delay (in ms) until moving into the "first" state. Counted
      *            from when {@link #trigger()} is called.
     /**
      * Returns the delay (in ms) which must pass before the loading indicator
      * moves to its "second" state.
-     * 
+     *
      * @return The delay (in ms) until the loading indicator moves into its
      *         "second" state. Counted from when {@link #trigger()} is called.
      */
     /**
      * Sets the delay (in ms) which must pass before the loading indicator moves
      * to its "second" state.
-     * 
+     *
      * @param secondDelay
      *            The delay (in ms) until the loading indicator moves into its
      *            "second" state. Counted from when {@link #trigger()} is
     /**
      * Returns the delay (in ms) which must pass before the loading indicator
      * moves to its "third" state.
-     * 
+     *
      * @return The delay (in ms) until the loading indicator moves into its
      *         "third" state. Counted from when {@link #trigger()} is called.
      */
     /**
      * Sets the delay (in ms) which must pass before the loading indicator moves
      * to its "third" state.
-     * 
+     *
      * @param thirdDelay
      *            The delay (in ms) from the event until changing the loading
      *            indicator into its "third" state. Counted from when
     /**
      * Triggers displaying of this loading indicator unless it's already visible
      * or scheduled to be shown after a delay.
-     * 
+     *
      * @since 7.4
      */
     public void ensureTriggered() {
     /**
      * Returns the {@link ApplicationConnection} which uses this loading
      * indicator
-     * 
+     *
      * @return The ApplicationConnection for this loading indicator
      */
     public ApplicationConnection getConnection() {
     /**
      * Sets the {@link ApplicationConnection} which uses this loading indicator.
      * Only used internally.
-     * 
+     *
      * @param connection
      *            The ApplicationConnection for this loading indicator
      */
 
     /**
      * Returns whether or not the loading indicator is showing.
-     * 
+     *
      * @return true if the loading indicator is visible, false otherwise
      */
     public boolean isVisible() {
 
     /**
      * Returns the root element of the loading indicator
-     * 
+     *
      * @return The loading indicator DOM element
      */
     public com.google.gwt.user.client.Element getElement() {

client/src/main/java/com/vaadin/client/VSchedulerImpl.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/VTooltip.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
      * Used to show tooltips; usually used via the singleton in
      * {@link ApplicationConnection}. NOTE that #setOwner(Widget)} should be
      * called after instantiating.
-     * 
+     *
      * @see ApplicationConnection#getVTooltip()
      */
     public VTooltip() {
 
     /**
      * Show the tooltip with the provided info for assistive devices.
-     * 
+     *
      * @param info
      *            with the content of the tooltip
      */
 
     /**
      * Initialize the tooltip overlay for assistive devices.
-     * 
+     *
      * @param info
      *            with the content of the tooltip
      * @since 7.2.4
              * element we need to clear style width of its parent DIV from old
              * value (in some strange cases this width=[tooltip MAX_WIDTH] after
              * tooltip text has been already updated to new shortly value:
-             * 
+             *
              * <div class="popupContent"> <div style="width:500px;"> <div
              * class="v-errormessage" aria-hidden="true" style="display: none;">
              * <div class="gwt-HTML"> </div> </div> <div
              * class="v-tooltip-text">This is a short tooltip</div> </div>
-             * 
+             *
              * and it leads to error during calculation offsetWidth (it is
              * native GWT method getSubPixelOffsetWidth()) of description
              * element")
 
     /**
      * Show a popup containing the currentTooltipInfo
-     * 
+     *
      */
     private void showTooltip() {
         if (currentTooltipInfo.hasMessage()) {
                  * Return the final X-coordinate of the tooltip based on cursor
                  * position, size of the tooltip, size of the page and necessary
                  * margins.
-                 * 
+                 *
                  * @param offsetWidth
                  * @return The final X-coordinate
                  */
                  * Return the final Y-coordinate of the tooltip based on cursor
                  * position, size of the tooltip, size of the page and necessary
                  * margins.
-                 * 
+                 *
                  * @param offsetHeight
                  * @return The final y-coordinate
-                 * 
+                 *
                  */
                 private int getFinalY(int offsetHeight) {
                     int y = 0;
      * and attached to the DOM well in advance. For this reason both isShowing
      * and isVisible return false positives. We can't override either of them as
      * external code may depend on this behavior.
-     * 
+     *
      * @return boolean
      */
     public boolean isTooltipOpen() {
 
         /**
          * Locate the tooltip for given element
-         * 
+         *
          * @param element
          *            Element used in search
          * @return TooltipInfo if connector and tooltip found, null if not
 
         /**
          * Handle hide event
-         * 
+         *
          */
         private void handleHideEvent() {
             hideTooltip();
 
         /**
          * Displays Tooltip when page is navigated with the keyboard.
-         * 
+         *
          * Tooltip is not visible. This makes it possible for assistive devices
          * to recognize the tooltip.
          */
 
         /**
          * Hides Tooltip when the page is navigated with the keyboard.
-         * 
+         *
          * Removes the Tooltip from page to make sure assistive devices don't
          * recognize it by accident.
          */
 
     /**
      * Connects DOM handlers to widget that are needed for tooltip presentation.
-     * 
+     *
      * @param widget
      *            Widget which DOM handlers are connected
      */
 
     /**
      * Returns the unique id of the tooltip element.
-     * 
+     *
      * @return String containing the unique id of the tooltip, which always has
      *         a value
      */
      * Returns the time (in ms) the tooltip should be displayed after an event
      * that will cause it to be closed (e.g. mouse click outside the component,
      * key down).
-     * 
+     *
      * @return The close timeout (in ms)
      */
     public int getCloseTimeout() {
      * Sets the time (in ms) the tooltip should be displayed after an event that
      * will cause it to be closed (e.g. mouse click outside the component, key
      * down).
-     * 
+     *
      * @param closeTimeout
      *            The close timeout (in ms)
      */
      * be used instead of {@link #getOpenDelay()}. The quick open delay is used
      * when the tooltip has very recently been shown, is currently hidden but
      * about to be shown again.
-     * 
+     *
      * @return The quick open timeout (in ms)
      */
     public int getQuickOpenTimeout() {
      * should be used instead of {@link #getOpenDelay()}. The quick open delay
      * is used when the tooltip has very recently been shown, is currently
      * hidden but about to be shown again.
-     * 
+     *
      * @param quickOpenTimeout
      *            The quick open timeout (in ms)
      */
      * Returns the time (in ms) that should elapse before a tooltip will be
      * shown, in the situation when a tooltip has very recently been shown
      * (within {@link #getQuickOpenDelay()} ms).
-     * 
+     *
      * @return The quick open delay (in ms)
      */
     public int getQuickOpenDelay() {
      * Sets the time (in ms) that should elapse before a tooltip will be shown,
      * in the situation when a tooltip has very recently been shown (within
      * {@link #getQuickOpenDelay()} ms).
-     * 
+     *
      * @param quickOpenDelay
      *            The quick open delay (in ms)
      */
      * tooltip showing has occurred (e.g. mouse over) before the tooltip is
      * shown. If a tooltip has recently been shown, then
      * {@link #getQuickOpenDelay()} is used instead of this.
-     * 
+     *
      * @return The open delay (in ms)
      */
     public int getOpenDelay() {
      * tooltip showing has occurred (e.g. mouse over) before the tooltip is
      * shown. If a tooltip has recently been shown, then
      * {@link #getQuickOpenDelay()} is used instead of this.
-     * 
+     *
      * @param openDelay
      *            The open delay (in ms)
      */
 
     /**
      * Sets the maximum width of the tooltip popup.
-     * 
+     *
      * @param maxWidth
      *            The maximum width the tooltip popup (in pixels)
      */
 
     /**
      * Returns the maximum width of the tooltip popup.
-     * 
+     *
      * @return The maximum width the tooltip popup (in pixels)
      */
     public int getMaxWidth() {

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

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * the License.
  */
 /**
- * 
+ *
  */
 package com.vaadin.client;
 
 
 /**
  * @author Vaadin Ltd
- * 
+ *
  * @deprecated as of 7.1. This class was mainly used by the old debug console
  *             but is retained for now for backwards compatibility.
  */

client/src/main/java/com/vaadin/client/ValueMap.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * the License.
  */
 /**
- * 
+ *
  */
 package com.vaadin.client;
 

client/src/main/java/com/vaadin/client/WidgetInstantiator.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/WidgetLoader.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/WidgetMap.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Abstract class mapping between {@link ComponentConnector} instances and their
  * instances.
- * 
+ *
  * A concrete implementation of this class is generated by WidgetMapGenerator or
  * one of its subclasses during widgetset compilation.
  */
 
     /**
      * Create a new instance of a connector based on its type.
-     * 
+     *
      * @param classType
      *            {@link ComponentConnector} class to instantiate
      * @return new instance of the connector
     /**
      * Return the connector class to use for a fully qualified server side
      * component class name.
-     * 
+     *
      * @param fullyqualifiedName
      *            fully qualified name of the server side component class
      * @return component connector class to use
     /**
      * Return the connector classes to load after the initial widgetset load and
      * start.
-     * 
+     *
      * @return component connector class to load after the initial widgetset
      *         loading
      */
      * Make sure the code for a (deferred or lazy) component connector type has
      * been loaded, triggering the load and waiting for its completion if
      * necessary.
-     * 
+     *
      * @param classType
      *            component connector class
      */

client/src/main/java/com/vaadin/client/WidgetSet.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
     /**
      * Create an uninitialized connector that best matches given UIDL. The
      * connector must implement {@link ServerConnector}.
-     * 
+     *
      * @param tag
      *            connector type tag for the connector to create
      * @param conf
      *            the application configuration to use when creating the
      *            connector
-     * 
+     *
      * @return New uninitialized and unregistered connector that can paint given
      *         UIDL.
      */
      * Due its nature, GWT does not support dynamic classloading. To bypass this
      * limitation, widgetset must have function that returns Class by its fully
      * qualified name.
-     * 
+     *
      * @param tag
      * @param applicationConfiguration
      * @return

client/src/main/java/com/vaadin/client/WidgetUtil.java

 
     /**
      * Helper method for debugging purposes.
-     * 
+     *
      * Stops execution on firefox browsers on a breakpoint.
-     * 
+     *
      */
     public static native void browserDebugger()
     /*-{
     /**
      * Redirects the browser to the given url or refreshes the page if url is
      * null
-     * 
+     *
      * @since 7.6
      * @param url
      *            The url to redirect to or null to refresh
      * Helper method for a bug fix #14041. For mozilla getKeyCode return 0 for
      * space bar (because space is considered as char). If return 0 use
      * getCharCode.
-     * 
+     *
      * @param event
      * @return return key code
      * @since 7.2.4
     }
 
     /**
-     * 
+     *
      * Returns the topmost element of from given coordinates.
-     * 
+     *
      * TODO fix crossplat issues clientX vs pageX. See quircksmode. Not critical
      * for vaadin as we scroll div istead of page.
-     * 
+     *
      * @param x
      * @param y
      * @return the element at given coordinates
 
     /**
      * Converts html entities to text.
-     * 
+     *
      * @param html
      * @return escaped string presentation of given html
      */
 
     /**
      * Escapes the string so it is safe to write inside an HTML attribute.
-     * 
+     *
      * @param attribute
      *            The string to escape
      * @return An escaped version of <literal>attribute</literal>.
 
     /**
      * Clones given element as in JavaScript.
-     * 
+     *
      * Deprecate this if there appears similar method into GWT someday.
-     * 
+     *
      * @param element
      * @param deep
      *            clone child tree also
 
     /**
      * Defers the execution of {@link #runWebkitOverflowAutoFix(Element)}
-     * 
+     *
      * @since 7.2.6
      * @param elem
      *            with overflow auto
 
     /**
      * Run workaround for webkits overflow auto issue.
-     * 
+     *
      * See: our bug #2138 and https://bugs.webkit.org/show_bug.cgi?id=21462
-     * 
+     *
      * @param elem
      *            with overflow auto
      */
     /**
      * Gets the border-box width for the given element, i.e. element width +
      * border + padding. Always rounds up to nearest integer.
-     * 
+     *
      * @param element
      *            The element to check
      * @return The border-box width for the element
     /**
      * Gets the border-box width for the given element, i.e. element width +
      * border + padding.
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            The element to check
     /**
      * Gets the border-box height for the given element, i.e. element height +
      * border + padding. Always rounds up to nearest integer.
-     * 
+     *
      * @param element
      *            The element to check
      * @return The border-box height for the element
     /**
      * Gets the border-box height for the given element, i.e. element height +
      * border + padding.
-     * 
+     *
      * @since 7.5.1
      * @param element
      *            The element to check
      * <p>
      * In case the browser doesn't support bounding rectangles, the returned
      * value is the offset width.
-     * 
+     *
      * @param element
      *            the element of which to calculate the width
      * @return the width of the element
      * <p>
      * In case the browser doesn't support bounding rectangles, the returned
      * value is the offset width.
-     * 
+     *
      * @param element
      *            the element of which to calculate the width
      * @return the subpixel-accurate width of the element
      * <p>
      * In case the browser doesn't support bounding rectangles, the returned
      * value is the offset height.
-     * 
+     *
      * @param element
      *            the element of which to calculate the height
      * @return the height of the element
      * <p>
      * In case the browser doesn't support bounding rectangles, the returned
      * value is the offset height.
-     * 
+     *
      * @param element
      *            the element of which to calculate the height
      * @return the subpixel-accurate height of the element
 
     /**
      * Detects what is currently the overflow style attribute in given element.
-     * 
+     *
      * @param pe
      *            the element to detect
      * @return true if auto or scroll
      * A simple helper method to detect "computed style" (aka style sheets +
      * element styles). Values returned differ a lot depending on browsers.
      * Always be very careful when using this.
-     * 
+     *
      * @param el
      *            the element from which the style property is detected
      * @param p
             com.google.gwt.dom.client.Element el, String p)
     /*-{
         try {
-    
+
         if (el.currentStyle) {
             // IE
             return el.currentStyle[p];
         } catch (e) {
             return "";
         }
-    
+
      }-*/;
 
     /**
      * Will (attempt) to focus the given DOM Element.
-     * 
+     *
      * @param el
      *            the element to focus
      */
         try {
             el.focus();
         } catch (e) {
-    
+
         }
     }-*/;
 
      * {@code C} or null, depending on whether the class parameter matches. This
      * may also be the case with other Composite-like classes that hijack the
      * event handling of their child widget(s).
-     * 
+     *
      * @param element
      *            the element where to start seeking of Widget
      * @param class1
 
     /**
      * Force webkit to redraw an element
-     * 
+     *
      * @param element
      *            The element that should be redrawn
      */
      * Performs a hack to trigger a re-layout in the IE8. This is usually
      * necessary in cases where IE8 "forgets" to update child elements when they
      * resize.
-     * 
+     *
      * @param e
      *            The element to perform the hack on
      */
      * Performs a hack to trigger a re-layout in the IE browser. This is usually
      * necessary in cases where IE "forgets" to update child elements when they
      * resize.
-     * 
+     *
      * @since 7.3
      * @param e
      *            The element to perform the hack on
     /**
      * Detaches and re-attaches the element from its parent. The element is
      * reattached at the same position in the DOM as it was before.
-     * 
+     *
      * Does nothing if the element is not attached to the DOM.
-     * 
+     *
      * @param element
      *            The element to detach and re-attach
      */
 
     /**
      * Returns the index of the childElement within its parent.
-     * 
+     *
      * @param subElement
      * @return
      */
      * Temporarily sets the {@code styleProperty} to {@code tempValue} and then
      * resets it to its current value. Used mainly to work around rendering
      * issues in IE (and possibly in other browsers)
-     * 
+     *
      * @param element
      *            The target element
      * @param styleProperty
      * A helper method to return the client position from an event. Returns
      * position from either first changed touch (if touch event) or from the
      * event itself.
-     * 
+     *
      * @param event
      * @return
      */
      * Find the element corresponding to the coordinates in the passed mouse
      * event. Please note that this is not always the same as the target of the
      * event e.g. if event capture is used.
-     * 
+     *
      * @param event
      *            the mouse event to get coordinates from
      * @return the element at the coordinates of the event
      * A helper method to return the client position from an event. Returns
      * position from either first changed touch (if touch event) or from the
      * event itself.
-     * 
+     *
      * @param event
      * @return
      */
     }
 
     /**
-     * 
+     *
      * @see #getTouchOrMouseClientY(Event)
      * @param currentGwtEvent
      * @return
 
     /**
      * @see #getTouchOrMouseClientX(Event)
-     * 
+     *
      * @param event
      * @return
      */
 
     /**
      * Gets the currently focused element.
-     * 
+     *
      * @return The active element or null if no active element could be found.
      */
     public native static Element getFocusedElement()
        if ($wnd.document.activeElement) {
            return $wnd.document.activeElement;
        }
-    
+
        return null;
      }-*/;
 
     /**
      * Gets currently focused element and checks if it's editable
-     * 
+     *
      * @since 7.4
-     * 
+     *
      * @return true if focused element is editable
      */
     public static boolean isFocusedElementEditable() {
      * this method checks that this widget nor any of its parents is hidden. Can
      * be e.g used to check whether component should react to some events or
      * not.
-     * 
+     *
      * @param widget
      * @return true if attached and displayed
      */
     /**
      * Scrolls an element into view vertically only. Modified version of
      * Element.scrollIntoView.
-     * 
+     *
      * @param elem
      *            The element to scroll into view
      */
     /*-{
         var top = elem.offsetTop;
         var height = elem.offsetHeight;
-    
+
         if (elem.parentNode != elem.offsetParent) {
           top -= elem.parentNode.offsetTop;
         }
-    
+
         var cur = elem.parentNode;
         while (cur && (cur.nodeType == 1)) {
           if (top < cur.scrollTop) {
           if (top + height > cur.scrollTop + cur.clientHeight) {
             cur.scrollTop = (top + height) - cur.clientHeight;
           }
-    
+
           var offsetTop = cur.offsetTop;
           if (cur.parentNode != cur.offsetParent) {
             offsetTop -= cur.parentNode.offsetTop;
           }
-    
+
           top += offsetTop - cur.scrollTop;
           cur = cur.parentNode;
         }
     /**
      * Checks if the given event is either a touch event or caused by the left
      * mouse button
-     * 
+     *
      * @param event
      * @return true if the event is a touch event or caused by the left mouse
      *         button, false otherwise
     /**
      * Resolve a relative URL to an absolute URL based on the current document's
      * location.
-     * 
+     *
      * @param url
      *            a string with the relative URL to resolve
      * @return the corresponding absolute URL as a string
 
     /**
      * Sets the selection range of an input element.
-     * 
+     *
      * We need this JSNI function to set selection range so that we can use the
      * optional direction attribute to set the anchor to the end and the focus
      * to the start. This makes Firefox work the same way as other browsers
      * (#13477)
-     * 
+     *
      * @param elem
      *            the html input element.
      * @param pos
      *            a string indicating the direction in which the selection was
      *            performed. This may be "forward" or "backward", or "none" if
      *            the direction is unknown or irrelevant.
-     * 
+     *
      * @since 7.3
      */
     public native static void setSelectionRange(Element elem, int pos,
 
     /**
      * JavaScript hack to prevent text selection in various browsers.
-     * 
+     *
      * @since 7.6
      * @param e
      *            element for enabling or disabling text selection
 
     /**
      * JavaScript hack to clear text selection in various browsers.
-     * 
+     *
      * @since 7.6
      */
     public native static void clearTextSelection()
     /**
      * Compares two double values with the error margin of
      * {@link #PIXEL_EPSILON} (i.e. {@value #PIXEL_EPSILON})
-     * 
+     *
      * @param num1
      *            the first value for which to compare equality
      * @param num2
      *            the second value for which to compare equality
      * @since 7.4
-     * 
+     *
      * @return true if the values are considered equals; false otherwise
      */
     public static boolean pixelValuesEqual(final double num1,
      * Wrap a css size value and its unit and translate back and forth to the
      * string representation.<br/>
      * Eg. 50%, 123px, ...
-     * 
+     *
      * @since 7.2.6
      * @author Vaadin Ltd
      */
 
         /**
          * Gets the unit value by its type.
-         * 
+         *
          * @param type
          *            the type of the unit as found in the style.
          * @return the unit value.
 
         /**
          * Parse the size from string format to {@link CssSize}.
-         * 
+         *
          * @param s
          *            the size as string.
          * @return a {@link CssSize} object.
 
         /**
          * Creates a {@link CssSize} using a value and its measurement unit.
-         * 
+         *
          * @param value
          *            the value.
          * @param unit
 
         /**
          * Gets the value for this css size.
-         * 
+         *
          * @return the value.
          */
         public float getValue() {
 
         /**
          * Gets the measurement unit for this css size.
-         * 
+         *
          * @return the unit.
          */
         public Unit getUnit() {
 
         /**
          * Check whether the two sizes are equals.
-         * 
+         *
          * @param cssSize1
          *            the first size to compare.
          * @param cssSize2
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
      * <p>
      * The value is determined using computed style when available and
      * calculated otherwise.
-     * 
+     *
      * @since 7.5.0
      * @param element
      *            the element to measure
             }
             var heightWithoutBorder = cloneElement.offsetHeight;
             parentElement.removeChild(cloneElement);
-            
+
             return heightWithBorder - heightWithoutBorder;
         }
     }-*/;
 
     /**
      * Rounds the given size up to a value which the browser will accept.
-     * 
+     *
      * Safari/WebKit uses 1/64th of a pixel to enable using integer math
      * (http://trac.webkit.org/wiki/LayoutUnit).
-     * 
+     *
      * Firefox uses 1/60th of a pixel because it is divisible by three
      * (https://bugzilla.mozilla.org/show_bug.cgi?id=1070940)
-     * 
+     *
      * @since 7.5.1
      * @param size
      *            the value to round
 
     /**
      * Rounds the given size down to a value which the browser will accept.
-     * 
+     *
      * Safari/WebKit uses 1/64th of a pixel to enable using integer math
      * (http://trac.webkit.org/wiki/LayoutUnit).
-     * 
+     *
      * Firefox uses 1/60th of a pixel because it is divisible by three
      * (https://bugzilla.mozilla.org/show_bug.cgi?id=1070940)
-     * 
+     *
      * IE9+ uses 1/100th of a pixel
-     * 
+     *
      * @since 7.5.1
      * @param size
      *            the value to round
 
     /**
      * Returns the factor used by browsers to round subpixel values
-     * 
+     *
      * @since 7.5.1
      * @return the factor N used by the browser when storing subpixels as X+Y/N
      */

client/src/main/java/com/vaadin/client/annotations/OnStateChange.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * <p>
  * If there is no state variable with the provided name, the widgetset
  * compilation will fail.
- * 
+ *
  * @since 7.2
  * @author Vaadin Ltd
  */
 public @interface OnStateChange {
     /**
      * Defines a list of property names to listen for.
-     * 
+     *
      * @return an array of property names, should contain at least one item
      */
     public String[] value();

client/src/main/java/com/vaadin/client/communication/AbstractServerConnectorEvent.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
     /**
      * Sends this event to the given handler.
-     * 
+     *
      * @param handler
      *            The handler to dispatch.
      */

client/src/main/java/com/vaadin/client/communication/AtmospherePushConnection.java

 /**
  * The default {@link PushConnection} implementation that uses Atmosphere for
  * handling the communication channel.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.1
  */
 
     /*
      * (non-Javadoc)
-     * 
+     *
      * @see
      * com.vaadin.client.communication.PushConnection#init(ApplicationConnection
      * , Map<String, String>, CommunicationErrorHandler)
     /**
      * Called whenever a server push connection is established (or
      * re-established).
-     * 
+     *
      * @param response
-     * 
+     *
      * @since 7.2
      */
     protected void onConnect(AtmosphereResponse response) {
 
     /*
      * (non-Javadoc)
-     * 
+     *
      * @see com.vaadin.client.communication.PushConenction#disconnect()
      */
     @Override
     /**
      * Called if the push connection fails. Atmosphere will automatically retry
      * the connection until successful.
-     * 
+     *
      */
     protected void onError(AtmosphereResponse response) {
         state = State.DISCONNECTED;
             JavaScriptObject config)
     /*-{
         var self = this;
-    
+
         config.url = uri;
         config.onOpen = $entry(function(response) {
             self.@com.vaadin.client.communication.AtmospherePushConnection::onOpen(*)(response);
         config.onClientTimeout = $entry(function(request) {
             self.@com.vaadin.client.communication.AtmospherePushConnection::onClientTimeout(*)(request);
         });
-    
+
         return $wnd.vaadinPush.atmosphere.subscribe(config);
     }-*/;
 

client/src/main/java/com/vaadin/client/communication/ConnectionStateHandler.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Interface for handling problems and other events which occur during
  * communication with the server.
- * 
+ *
  * The handler is responsible for handling any problem in XHR, heartbeat and
  * push connections in a way it sees fit. The default implementation is
  * {@link DefaultConnectionStateHandler}.
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */
 
     /**
      * Called when an exception occurs during a {@link Heartbeat} request
-     * 
+     *
      * @param request
      *            The heartbeat request
      * @param exception
 
     /**
      * Called when a heartbeat request returns a status code other than OK (200)
-     * 
+     *
      * @param request
      *            The heartbeat request
      * @param response
      * result in the push connection trying a fallback connection method, trying
      * to reconnect to the server or might just be an indication that the
      * connection was intentionally closed ("unsubscribe"),
-     * 
+     *
      * @param pushConnection
      *            The push connection which was closed
      * @param response
     /**
      * Called when a client side timeout occurs before a push connection to the
      * server completes.
-     * 
+     *
      * The client side timeout causes a disconnection of the push connection and
      * no reconnect will be attempted after this method is called,
-     * 
+     *
      * @param pushConnection
      *            The push connection which timed out
      * @param response
 
     /**
      * Called when a fatal error fatal error occurs in the push connection.
-     * 
+     *
      * The push connection will not try to recover from this situation itself
      * and typically the problem handler should not try to do automatic recovery
      * either. The cause can be e.g. maximum number of reconnection attempts
      * have been reached, neither the selected transport nor the fallback
      * transport can be used or similar.
-     * 
+     *
      * @param pushConnection
      *            The push connection where the error occurred
      * @param response
     /**
      * Called when the push connection has lost the connection to the server and
      * will proceed to try to re-establish the connection
-     * 
+     *
      * @param pushConnection
      *            The push connection which will be reconnected
      */
 
     /**
      * Called when the push connection to the server has been established.
-     * 
+     *
      * @param pushConnection
      *            The push connection which was established
      */
 
     /**
      * Called when the required push script could not be loaded
-     * 
+     *
      * @param resourceUrl
      *            The URL which was used for loading the script
      */
     /**
      * Called when an exception occurs during an XmlHttpRequest request to the
      * server.
-     * 
+     *
      * @param xhrConnectionError
      *            An event containing what was being sent to the server and what
      *            exception occurred
     /**
      * Called when invalid content (not JSON) was returned from the server as
      * the result of an XmlHttpRequest request
-     * 
+     *
      * @param communicationProblemEvent
      *            An event containing what was being sent to the server and what
      *            was returned
     /**
      * Called when invalid status code (not 200) was returned by the server as
      * the result of an XmlHttpRequest.
-     * 
+     *
      * @param communicationProblemEvent
      *            An event containing what was being sent to the server and what
      *            was returned
     /**
      * Called when a message is to be sent to the server through the push
      * channel but the push channel is not connected
-     * 
+     *
      * @param payload
      *            The payload to send to the server
      */
     /**
      * Called when invalid content (not JSON) was pushed from the server through
      * the push connection
-     * 
+     *
      * @param communicationProblemEvent
      *            An event containing what was being sent to the server and what
      *            was returned

client/src/main/java/com/vaadin/client/communication/Date_Serializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Client side serializer/deserializer for java.util.Date
- * 
+ *
  * @since 7.2
  * @author Vaadin Ltd
  */

client/src/main/java/com/vaadin/client/communication/DefaultConnectionStateHandler.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * <p>
  * Handles permanent errors by showing a critical system notification to the
  * user
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */
 
         /**
          * Checks if this type is of higher priority than the given type
-         * 
+         *
          * @param type
          *            the type to compare to
          * @return true if this type has higher priority than the given type,
 
     /**
      * Checks if we are currently trying to reconnect
-     * 
+     *
      * @return true if we have noted a problem and are trying to re-establish
      *         server connection, false otherwise
      */
 
     /**
      * Returns the connection this handler is connected to
-     * 
+     *
      * @return the connection for this handler
      */
     protected ApplicationConnection getConnection() {
      * Called whenever an error occurs in communication which should be handled
      * by showing the reconnect dialog and retrying communication until
      * successful again
-     * 
+     *
      * @param type
      *            The type of failure detected
      * @param payload
 
     /**
      * Called after a problem occurred.
-     * 
+     *
      * This method is responsible for re-sending the payload to the server (if
      * not null) or re-send a heartbeat request at some point
-     * 
+     *
      * @param payload
      *            the payload that did not reach the server, null if the problem
      *            was detected by a heartbeat
     /**
      * Re-sends the payload to the server (if not null) or re-sends a heartbeat
      * request immediately
-     * 
+     *
      * @param payload
      *            the payload that did not reach the server, null if the problem
      *            was detected by a heartbeat
     /**
      * Called when we should give up trying to reconnect and let the user decide
      * how to continue
-     * 
+     *
      */
     protected void giveUp() {
         reconnectionCause = null;
 
     /**
      * Checks if the reconnect dialog is visible to the user
-     * 
+     *
      * @return true if the user can see the dialog, false otherwise
      */
     protected boolean isDialogVisible() {
     /**
      * Gets the text to show in the reconnect dialog after giving up (reconnect
      * limit reached)
-     * 
+     *
      * @param reconnectAttempt
      *            The number of the current reconnection attempt
      * @return The text to show in the reconnect dialog after giving up
 
     /**
      * Gets the text to show in the reconnect dialog
-     * 
+     *
      * @param reconnectAttempt
      *            The number of the current reconnection attempt
      * @return The text to show in the reconnect dialog

client/src/main/java/com/vaadin/client/communication/DefaultReconnectDialog.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * The default implementation of the reconnect dialog
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */

client/src/main/java/com/vaadin/client/communication/DiffJSONSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 public interface DiffJSONSerializer<T> extends JSONSerializer<T> {
     /**
      * Update the target object in place based on the passed JSON data.
-     * 
+     *
      * @param target
      * @param jsonValue
      * @param connection

client/src/main/java/com/vaadin/client/communication/HasJavaScriptConnectorHelper.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/communication/Heartbeat.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
 /**
  * Handles sending of heartbeats to the server and reacting to the response
- * 
+ *
  * @since 7.2
  * @author Vaadin Ltd
  */
 
     /**
      * Initializes the heartbeat for the given application connection
-     * 
+     *
      * @param connection
      *            the connection
      */
 
     /**
      * Changes the heartbeatInterval in runtime and applies it.
-     * 
+     *
      * @param heartbeatInterval
      *            new interval in seconds.
      */

client/src/main/java/com/vaadin/client/communication/JSONSerializer.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * <p>
  * This is the client side interface, see
  * com.vaadin.server.communication.JSONSerializer for the server side interface.
- * 
+ *
  * @since 7.0
  */
 public interface JSONSerializer<T> {
      * Creates and deserializes an object received from the server. Must be
      * compatible with {@link #serialize(Object, ApplicationConnection)} and
      * also with the server side JsonCodec.encode method.
-     * 
+     *
      * @param type
      *            the type to deserialize
      * @param jsonValue
      *            JSON map from property name to property value
      * @param connection
      *            the application connection providing the context
-     * 
+     *
      * @return A deserialized object
      */
     T deserialize(Type type, JsonValue jsonValue,
      * Serialize the given object into JSON. Must be compatible with
      * {@link #deserialize(Type, JsonValue, ApplicationConnection)} and also
      * with the server side JsonCodec.decodeCustomType method.
-     * 
+     *
      * @param value
      *            The object to serialize
      * @param connection

client/src/main/java/com/vaadin/client/communication/JavaScriptMethodInvocation.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * A {@link MethodInvocation} that originates from JavaScript. This means that
  * there might not be any type information available on the client.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.0.0
  */

client/src/main/java/com/vaadin/client/communication/JsonDecoder.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

client/src/main/java/com/vaadin/client/communication/JsonEncoder.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 /**
  * Encoder for converting RPC parameters and other values to JSON for transfer
  * between the client and the server.
- * 
+ *
  * Currently, basic data types as well as Map, String[] and Object[] are
  * supported, where maps and Object[] can contain other supported data types.
- * 
+ *
  * TODO extensible type support
- * 
+ *
  * @since 7.0
  */
 public class JsonEncoder {
     /**
      * Encode a value to a JSON representation for transport from the client to
      * the server.
-     * 
+     *
      * @param value
      *            value to convert
      * @param connection
     /**
      * Returns the transport type for the given value. Only returns a transport
      * type for internally handled values.
-     * 
+     *
      * @param value
      *            The value that should be transported
      * @return One of the JsonEncode.VTYPE_ constants or null if the value

client/src/main/java/com/vaadin/client/communication/MessageHandler.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * A MessageHandler is responsible for handling all incoming messages (JSON)
  * from the server (state changes, RPCs and other updates) and ensuring that the
  * connectors are updated accordingly.
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */
      * has not yet been rendered (or that your browser is very fast). -1 means
      * that the browser does not support the performance.timing feature used to
      * get this measurement.
-     * 
+     *
      * Note: also used for tracking whether the first UIDL has been handled
      */
     private int bootstrapTime = 0;
     /**
      * Sets the application connection this instance is connected to. Called
      * internally by the framework.
-     * 
+     *
      * @param connection
      *            the application connection this instance is connected to
      */
     /**
      * Handles a received UIDL JSON text, parsing it, and passing it on to the
      * appropriate handlers, while logging timing information.
-     * 
+     *
      * @param jsonText
      *            The JSON to handle
      */
             /**
              * Sends the state change events created while updating the state
              * information.
-             * 
+             *
              * This must be called after hierarchy change listeners have been
              * called. At least caption updates for the parent are strange if
              * fired from state change listeners and thus calls the parent
              * BEFORE the parent is aware of the child (through a
              * ConnectorHierarchyChangedEvent)
-             * 
+             *
              * @param pendingStateChangeEvents
              *            The events to send
              */
              * Updates the connector hierarchy and returns a list of events that
              * should be fired after update of the hierarchy and the state is
              * done.
-             * 
+             *
              * @param json
              *            The JSON containing the hierarchy information
              * @return A collection of events that should be fired when update
 
             /**
              * Updates the hierarchy for a connector
-             * 
+             *
              * @param connectorId
              *            the id of the connector to update
              * @param childConnectorIds
     /**
      * This method can be used to postpone rendering of a response for a short
      * period of time (e.g. to avoid the rendering process during animation).
-     * 
+     *
      * @param lock
      */
     public void suspendReponseHandling(Object lock) {
 
     /**
      * Resumes the rendering process once all locks have been removed.
-     * 
+     *
      * @param lock
      */
     public void resumeResponseHandling(Object lock) {
     /**
      * Finds the next pending UIDL message and handles it (next pending is
      * decided based on the server id)
-     * 
+     *
      * @return true if a message was handled, false otherwise
      */
     private boolean handlePendingMessages() {
      * server is received.
      * <p>
      * The initial id when no request has yet been processed is -1.
-     * 
+     *
      * @return an id identifying the response
      */
     public int getLastSeenServerSyncId() {
     /**
      * Gets the token (aka double submit cookie) that the server uses to protect
      * against Cross Site Request Forgery attacks.
-     * 
+     *
      * @return the CSRF token string
      */
     public String getCsrfToken() {
      * operations are not allowed when the internal state of the application
      * might be in an inconsistent state because some state changes have been
      * applied but others not. This includes running layotus.
-     * 
+     *
      * @return <code>true</code> if the internal state might be inconsistent
      *         because changes are being processed; <code>false</code> if the
      *         state should be consistent
 
     /**
      * Checks if the first UIDL has been handled
-     * 
+     *
      * @return true if the initial UIDL has already been processed, false
      *         otherwise
      */
 
     /**
      * Strips the JSON wrapping from the given json string with wrapping.
-     * 
+     *
      * If the given string is not wrapped as expected, returns null
-     * 
+     *
      * @since 7.6
      * @param jsonWithWrapping
      *            the JSON received from the server
 
     /**
      * Unwraps and parses the given JSON, originating from the server
-     * 
+     *
      * @param jsonText
      *            the json from the server
      * @return A parsed ValueMap or null if the input could not be parsed (or
 
     /**
      * Parse the given wrapped JSON, received from the server, to a ValueMap
-     * 
+     *
      * @param wrappedJsonText
      *            the json, wrapped as done by the server
      * @return a ValueMap, or null if the wrapping was incorrect or json could

client/src/main/java/com/vaadin/client/communication/MessageSender.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * <p>
  * Internally uses {@link XhrConnection} and/or {@link PushConnection} for
  * delivering messages, depending on the application configuration.
- * 
+ *
  * @since 7.6
  * @author Vaadin Ltd
  */
     /**
      * Sends all pending method invocations (server RPC and legacy variable
      * changes) to the server.
-     * 
+     *
      */
     private void doSendInvocationsToServer() {
 
 
     /**
      * Makes an UIDL request to the server.
-     * 
+     *
      * @param reqInvocations
      *            Data containing RPC invocations and all related information.
      * @param extraParams
     /**
      * Sends an asynchronous or synchronous UIDL request to the server using the
      * given URI.
-     * 
+     *
      * @param uri
      *            The URI to use for the request. May includes GET parameters
      * @param payload
 
     /**
      * Sets the status for the push connection.
-     * 
+     *
      * @param enabled
      *            <code>true</code> to enable the push connection;
      *            <code>false</code> to disable the push connection.
     /**
      * Runs possibly registered client side post request hooks. This is expected
      * to be run after each uidl request made by Vaadin application.
-     * 
+     *
      * @param appId
      */
     public static native void runPostRequestHooks(String appId)
     /**
      * If on Liferay and logged in, ask the client side session management
      * JavaScript to extend the session duration.
-     * 
+     *
      * Otherwise, Liferay client side JavaScript will explicitly expire the
      * session even though the server side considers the session to be active.
      * See ticket #8305 for more information.
     /**
      * Indicates whether or not there are currently active UIDL requests. Used
      * internally to sequence requests properly, seldom needed in Widgets.
-     * 
+     *
      * @return true if there are active requests
      */
     public boolean hasActiveRequest() {
     /**
      * Returns a human readable string representation of the method used to
      * communicate with the server.
-     * 
+     *
      * @return A string representation of the current transport type
      */
     public String getCommunicationMethodName() {
 
     /**
      * Used internally to update what the server expects
-     * 
+     *
      * @param clientToServerMessageId
      *            the new client id to set
      * @param force

client/src/main/java/com/vaadin/client/communication/PushConnection.java

 /*
  * Copyright 2000-2014 Vaadin Ltd.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * receive UIDL messages from the server (either asynchronously or as a response
  * to a UIDL request.) Delegates the UIDL handling to the
  * {@link ApplicationConnection}.
- * 
+ *
  * @author Vaadin Ltd
  * @since 7.1
  */
 
     /**
      * Two-phase construction to allow using GWT.create().
-     * 
+     *
      * @param connection
      *            The ApplicationConnection
      */
      * <p>
      * This method must not be called if the push connection is not
      * bidirectional (if {@link #isBidirectional()} returns false)
-     * 
+     *
      * @param payload
      *            the payload to push
      * @throws IllegalStateException
      *             if this connection is not active
-     * 
+     *
      * @see #isActive()
      */
     public void push(JsonObject payload);
      * Checks whether this push connection is in a state where it can push
      * messages to the server. A connection is active until
      * {@link #disconnect(Command)} has been called.
-     * 
+     *
      * @return <code>true</code> if this connection can accept new messages;
      *         <code>false</code> if this connection is disconnected or
      *         disconnecting.
      * After this method has been called, {@link #isActive()} returns
      * <code>false</code>. Calling this method for a connection that is no
      * longer active will throw an exception.
-     * 
+     *
      * @param command
      *            callback command invoked when the connection has been properly
      *            disconnected
     /**
      * Returns a human readable string representation of the transport type used
      * to communicate with the server.
-     * 
+     *
      * @since 7.1
      * @return A human readable string representation of the transport type
      */
      * Checks whether this push connection should be used for communication in
      * both directions or if an XHR should be used for client to server
      * communication.
-     * 
+     *
      * A bidirectional push connection must be able to reliably inform about its
      * connection state.
-     * 
+     *
      * @since 7.6
      * @return true if the push connection should be used for messages in both
      *         directions, false if it should only be used for server to client