<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head>
      <meta http-equiv="content-type" content="text/html; charset=utf-8">
      <title>Google Web Toolkit Release Notes</title>
      
      <style>
         body {
            background-color: white;
            color: black;
            font-family: Arial, sans-serif;
            font-size: small;
            margin: 20px;
         }

         li {
            margin-bottom: 0.5em;
         }

         li div {
            margin-top: 0.2em;
         }

         code {
            font-size: medium;
         }
      </style></head>

   <body>
      <h1>Google Web Toolkit Release Notes</h1>
      <ul>
		    <li><a href="#Release_Notes_Current">@GWT_VERSION@</a></li>
		    <li><a href="#Release_Notes_1_3_3">1.3.3</a></li>
		    <li><a href="#Release_Notes_1_3_1">1.3.1 (RC)</a></li>
		    <li><a href="#Release_Notes_1_2_22">1.2.22</a></li>
		    <li><a href="#Release_Notes_1_2_11">1.2.21 (RC)</a></li>
		    <li><a href="#Release_Notes_1_1_10">1.1.10</a></li>
		    <li><a href="#Release_Notes_1_1_0">1.1.0 (RC)</a></li>
		    <li><a href="#Release_Notes_1_0_21">1.0.21</a></li>
      </ul>

      <hr/>
      <a name="Release_Notes_Current"></a>
      <h2>Release Notes for @GWT_VERSION@</h2>
      <p>
      This is the Release Candidate for GWT 1.4, the first GWT release developed with major participation
      from GWT open source contributors.  It's been a long time coming, but we hope it's been worth the wait.
      In addition to tons of new features, optimizations, and performance enhancements, we've fixed more than
      150 bugs.  There are some important behavioral and potentially breaking API changes; if you read nothing
      else, please read these following sections!
      </p>

      <h3>Behavioral Changes</h3>
      <p>Important changes in the behavior of existing GWT features.</p>
      <h4>Critical Changes to RPC</h4>
      In general, the old RPC system was too lenient and failed to warn at compile time about things
      that could cause problems at runtime.  You may find that the new RPC system emits a lot of warnings (or
      even errors) for code that works (or used to work) just fine.  While this may be annoying in the short
      term, fixing your code to avoid these warnings will result in a smaller, faster, and more reliable app.
      <ul>
        <li><b>Bad code that worked before might not now</b><br/>
        Previously, if you declared one particular component type via gwt.typeArgs at compile time, you could
        often get away with passing a different type at runtime.  For example, placing a Date in an
        ArrayList of String might work.  This type of code is less likely to work now, and we hope to be even
        stricter in the future.  Bottom line: don't do this.
        </li>
        <li><b><a href="doc/html/java.io.Serializable.html">Serializable</a> equivalent to
        <a href="doc/html/com.google.gwt.user.client.rpc.IsSerializable.html">IsSerializable</a></b><br/>
        We don't support any of the semantics of Java serialization, but by popular demand, Serializable and
        IsSerializable are now equivalent for the purposes of RPC.  This should improve server-side
        interoperability and remove much of the need for DTOs.
        </li>
        <li><b>Warn about missing gwt.typeArgs</b><br/>
        Every Collection or Map type should have an associated
        <a href="doc/html/com.google.gwt.doc.DeveloperGuide.RemoteProcedureCalls.SerializableTypes.html">gwt.typeArgs
        javadoc annotation</a>.  In the past, a missing gwt.typeArgs would generally have no noticeable effect,
        because a bug in the RPC system would generate code for all available serializable types, even if they
        weren't used in your service interface.  Now that this bug has been fixed, you can achieve <b>significant</b>
        shrinkage in the size of your compiled output by fixing these warnings.
        </li>
        <li><b>Warn about serializable subclasses that violate the serialization restrictions</b><br/>
        If you have a class that implements IsSerializable or Serializable, but that class lacks a default
        constructor or contains fields which cannot be serialized, a compile time warning will be generated.
        Resolve these warnings to avoid exceptions being thrown at runtime.
        </li>
        <li><b>Warn about non-transient, final instance fields</b><br/>
        We have never serialized this type of field, and now we will warn about the existence of such fields.  The
        warning can be suppressed via a module property.
        </li>
        <li><b>Warn about local and non-static nested types that implement IsSerializable or Serializable</b><br/>
        We have never serialized these types of classes and will now generate a warning.
        </li>
        <li><b>Warn about native methods in serializable classes</b><br/>
        We warn about this condition because it will cause UnsatisfiedLinkErrors if method is called on the server.
        </li>
      </ul>
      <h4>Module Script Tags</h4>
      <ul>
        <li>In previous versions of GWT, a script tag contained a nested JavaScript expression that would
        determine when the script had been successfully loaded.  Script load order is now handled automatically and
        these expressions are ignored.  A warning will be issued in hosted mode.  For reference, see
        <a href="doc/html/com.google.gwt.doc.DeveloperGuide.Fundamentals.Modules.AutomaticResourceInjection.html">here</a>.
        </li>
      </ul>
      <h4>More Hosted Mode Checks Related to JSNI</h4>
      <ul>
        <li>Previously, when passing values from JavaScript into Jave, hosted mode would silently coerce
        a JavaScript value of an incorrect type into the declared Java type.  Unforunately, this would
        allow code to work in hosted mode that could fail in unexpected ways in web mode.  Hosted mode
        will now throw a HostedModeException if you try to pass an incompatible type.  See
        <a href="doc/html/com.google.gwt.doc.DeveloperGuide.JavaScriptNativeInterface.Marshaling.html">here</a>
        for more details.
        </li>
      </ul>

      <h3>Breaking API Changes</h3>
      We've made a few API changes in this release that may require minor tweaks to existing code.  Any such changes
      that affect you should only take a few minutes to rectify.

      <h4><a href="doc/html/com.google.gwt.core.client.JavaScriptObject.html">JavaScriptObject</a></h4>
      <ul>
        <li>Although subclassing JavaScriptObject is still not supported, we know some of you have done this anyway. :) The
        existing (int) constructor has been removed in favor of a protected no-arg constructor.  Read the source code for
        <a href="doc/html/com.google.gwt.user.client.Element.html">Element</a> for an example of how JavaScriptObject must
        be subclassed now.
        </li>
      </ul>
      <h4><a href="doc/html/com.google.gwt.user.client.DeferredCommand.html">DeferredCommand</a></h4>
      <ul>
        <li>We've deprecated the add() method in favor of addCommand() in order to support the new
        <a href="doc/html/com.google.gwt.user.client.IncrementalCommand.html">IncrementalCommand</a> interface.  Had we
        simply added a new method overload, existing code that passed in a null literal would have failed to compile.</li>
        <li>The new addPause() method should be used instead of add(null).</li>
      </ul>
      <h4><a href="doc/html/com.google.gwt.user.client.ui.UIObject.html">UIObject</a></h4>
      <ul>
        <li>We've formalized the way style names are handled in UIObject (which applies to all widgets as well). Style
        names have been separated into "base", "dependent", and "secondary" styles, which are detailed in the UIObject
        documentation. The interface is unchanged (get/setStyleName(), add/removeStyleName()), and should not affect most
        widgets. One potentially breaking change: widgets may no longer use removeStyleName() to remove the "base" style
        name. See the UIObject documentation for a full explanation.</li>
      </ul>

      <h3>New Features</h3>
      Here are a few of the coolest new features and enhancements in GWT 1.4.
      <ul>
        <li><b>Size and Speed Optimizations</b><ul>
           <li>New <a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=610">size</a>
           <a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=599">improvements</a> in the GWT compiler
           produce JavaScript that is 10-20% smaller; just recompile your app with 1.4.</li>
           <li>An enhanced startup sequence reduces the size of your module's startup script by 80%. More importantly, the
           new startup sequence removes an HTTP round-trip, making startup latency about 33% faster.</li>
           <li>The above optimizations combined with <a href="#ImageBundle">ImageBundle</a>, make it possible for GWT-based applications
           to load surprisingly quickly. To see for yourself, check out startup time of the
           <a href="samples/Mail/www/com.google.gwt.sample.mail.Mail/Mail.html">Mail</a> sample.</li>
        </ul></li>
        <li><b>Deployment Enhancements</b><ul>
           <li>GWT RPC is no longer tied to exclusively to servlets. New
           <a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=389">modularized RPC</a> server code makes
           it easy to connect GWT RPC to your choice of Java back-ends.</li>
           <li>Adding GWT modules to an HTML page has been simplified. Instead of adding a &lt;meta name='gwt:module'&gt; and
           &lt;script src='gwt.js'&gt;, you just add a single script element for your module.</li>
           <li>Cross-site script inclusion is now supported. The compiler produces a "-xs" (meaning "cross-site") version of
           your module's startup script that can be included without being restricted by the same-origin policy. WARNING:
           including scripts from other sites that you don't fully trust is a
           <a href="http://groups.google.com/group/Google-Web-Toolkit/web/security-for-gwt-applications">big security risk</a>.</li>
        </ul></li>
        <li><b>Widget and Library Enhancements</b><ul>
           <li><a href="doc/html/com.google.gwt.user.client.ui.RichTextArea.html">RichTextArea</a> allows "drop in"
           functionality for rich text editing.</li>
           <li><a href="doc/html/com.google.gwt.user.client.ui.SuggestBox.html">SuggestBox</a> makes it easy to add
           auto-complete functionality.</li>
           <li>Splitters! <a href="doc/html/com.google.gwt.user.client.ui.HorizontalSplitPanel.html">HorizontalSplitPanel</a>
           and <a href="doc/html/com.google.gwt.user.client.ui.VerticalSplitPanel.html">VerticalSplitPanel</a> enable you to
           resize portions of the user interface.</li>
           <li><a href="doc/html/com.google.gwt.user.client.ui.PushButton.html">PushButton</a> and
           <a href="doc/html/com.google.gwt.user.client.ui.ToggleButton.html">ToggleButton</a> are easy-to-customize button
           widgets that can enhance the look-and-feel of your UI.</li>
           <li><a href="doc/html/com.google.gwt.user.client.ui.DisclosurePanel.html">DisclosurePanel</a> is a simple,
           nice-looking panel that lets users easily hide and show portions of your application UI.</li>
           <li><a href="doc/html/com.google.gwt.i18n.client.DateTimeFormat.html">DateTimeFormat</a> and
           <a href="doc/html/com.google.gwt.i18n.client.NumberFormat.html">NumberFormat</a> make it easy to format and parse
           dates, times, and numbers for users all over the world.</li>
           <li><a href="doc/html/com.google.gwt.user.client.IncrementalCommand.html">IncrementalCommand</a> helps you
           implement long-running tasks in your client code without triggering "slow script" warnings.</li>
           <li>A new <a href="http://docs.google.com/View?docid=d9s6nb7_1d723ft">benchmarking subsystem</a> integrates with
           JUnit to let you record and compare the speed of code snippets across multiple browsers and multiple parameter
           ranges. Benchmarking is a powerful way to identify bottlenecks and compare performance of alternative implementations.</li>
           <li>The oft-requested <a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=21">java.io.Serializable</a> is
           now included in the JRE emulation library and is synonymous with IsSerializable for the purpose of GWT RPC.</li>
           <li><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=844">Mouse wheel events</a> are now available
           on a variety of widgets.</li>
        </ul></li>
        <a name="#ImageBundle"></a>
        <li><b><a href="doc/html/com.google.gwt.user.client.ui.ImageBundle.html">ImageBundle</a></b><ul>
           <li>ImageBundle is the single biggest have-to-see-it-to-believe-it feature in this release. Image bundles make it trivially
           easy to combine dozens of images into a single "image strip", collapsing what would have been dozens of HTTP requests into
           one: a single, permanently-cacheable image file.</li>
           <li>Image bundles manage everything for you automatically, from computing clipping rectangles to making transparent PNGs
           work in IE6. You can even choose to get the clipped image as an Image widget or as pure HTML for inclusion in a larger HTML
           template.</li>
           <li>In addition to enabling a blazing-fast startup, image bundles help make the UI look better during startup, too. Typical
           AJAX apps exhibit "bouncy relayout" as individual images are loaded one-at-a-time. Fixing this problem has historically
           required laboriously pre-initializing the width and height of each individual image ahead of time. Image bundles do the
           same thing automatically. The dimensions of each clipped image are computed at compile time while the bundled
           image file is being created. Voila! The result is a fast, non-ugly user startup experience that requires no extra work on
           the part of the GWT developer to keep up-to-date.</li>
           <li>See the <a href="http://code.google.com/p/google-web-toolkit/wiki/ImageBundleDesign">design doc</a> for more
           details.</li>
        </ul></li>
      </ul>
      
      <p>
      See the GWT issue tracker for
      <a href="http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=status%3AFixed%20milestone%3A1_4_RC%20type%3Aenhancement&num=1000">the
      complete list of enhancements</a> in this release.</p>
 
      <h3>Fixed Issues</h3>
      <p>
      See the GWT issue tracker for
      <a href="http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=status%3AFixed%20milestone%3A1_4_RC%20type%3Adefect&num=1000">the
      complete list of bug fixes</a> in this release.</p>

      <hr/>
      <a name="Release_Notes_1_3_3"></a>
      <h2>Release Notes for 1.3.3</h2>
      <p>
      This version has only minor functional changes from 1.3.1, listed below.
      </p>

      <h3>Fixed Issues</h3>
      <ul>
        <li><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=319">Issue #319 - Calling native super method in implementation class results in infinite loop in web mode</a></li>
        <li><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=496">Issue #496 - gwt.js in gwt-user.jar lacks Apache 2.0 license header</a></li>
        <li><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=497">Issue #497 - Unexpected internal compiler error - Analyzing permutation #1</a></li>
      </ul>

      <hr/>
      <a name="Release_Notes_1_3_1"></a>
      <h2>Release Notes for 1.3.1 (RC)</h2>
      <p>
      This is the Release Candidate for GWT 1.3, the first completely open source version of GWT. 
      This version has no new functionality, but we did make a lot of changes to get the source code and build scripts into presentable shape to prepare for ongoing open source development.
      Although the changes were relatively harmless -- formatting, sorting, more documentation, and a new build system -- there's always a small chance of problems, so we plan to call this a Release Candidate until we've convinced ourselves it's reliable.
      </p>

      <h3>Useful Links</h3>
      <ul>
        <li><b><a href="http://code.google.com/webtoolkit/makinggwtbetter.html">Making GWT Better</a></b>
        <br>This is our new GWT open source charter that describes how we plan to operate the project and how you can access the GWT source, compile it yourself, and contribute.</li>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/list">The GWT Issue Tracker</a></b>
        <br>Please report any bugs in 1.3 RC that weren't in 1.2.22 in the GWT issue tracker. These would be likely related to the new build, and we want to know ASAP so we can fix them.</li>
        <li><b><a href="http://google-web-toolkit.googlecode.com/svn/">The GWT Subversion Repository</a></b>
        <br>Visit the online repository to browse the GWT source without a Subversion client.</li>
      </ul>
      
      <hr/>
      <a name="Release_Notes_1_2_22"></a>
      <h2>Release Notes for 1.2.22</h2>
      <p>
      This is the official GWT 1.2 release, the follow up to the <a href="#Release_Notes_1_2_11">GWT 1.2 Release Candidate</a>.
      It includes all of the enhancements and bug fixes from GWT 1.2 RC as well as a few additional bug fixes that were reported against GWT 1.2 RC.</p>
      
      <h3>About OS X Hosted Mode Support</h3>
      GWT's hosted mode support is available only on OS X 1.4 (Tiger) or later.

      <h3>Useful Links</h3>
      <ul>
        
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=status%3AFixed%20milestone%3A1_2_Final">Changes included in GWT 1.2 since the RC</a></b>
        <br>Also see the GWT Blog for a discussion of the <a href="http://googlewebtoolkit.blogspot.com/2006/11/wrapping-up-gwt-12-soon.html">noteworthy issues related to 1.2 RC</a></li>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=status%3AFixed%20milestone%3A1_2_RC">New features and bug fixes in GWT 1.2 RC</a></b></li>
      </ul>
      
      <h3>Breaking API Changes</h3>
      There are no breaking changes to pre-1.2 APIs, but one method has been renamed in a class that was new in 1.2 RC.
      
      <h4>com.google.gwt.http.client.RequestBuilder</h4>
      The method <code>addHeader()</code> was renamed to <code>setHeader()</code> to more clearly reflect its intent. 
      You will only be affected by this change if you are using the new HTTP functionality available as of build 1.2.11.

      <hr/>
      <a name="Release_Notes_1_2_11"></a>
      <h2>Release Notes for 1.2.11 (RC)</h2>
      <p>
      This is the Release Candidate for GWT 1.2. 
      Between this build and the subsequent GWT 1.2 official release, changes are limited to issues unique to GWT 1.2 RC.
      
      <p>
      See the GWT issue tracker for <a href="http://code.google.com/p/google-web-toolkit/issues/list?can=1&q=status%3AFixed%20milestone%3A1_2_RC">the complete list of enhancements and bug fixes</a> in this release.</p>
      
      <h3>New Features</h3>
      <ul>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=91">Full support for OS X development</a></b>
        <br>Develop with GWT on OS X as easily as on Linux and Windows</li>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=93">Much faster hosted mode</a></b>
        <br>Hosted mode startup time has improved significantly, but, even better, refreshes are now lightning fast &mdash; even when your source changes</li>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=52">New HTTP request module</a></b>
        <br>The HTTP functionality that GWT users have been asking for (custom headers, status code, timeouts, and more), all wrapped up in an API that's easier to use than the JavaScript XMLHttpRequest object</li>
        <li><b><a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=10">Widgets in TreeItems</a></b>
        <br>Tree items can now contain arbitrary widgets...finally, you can easily create trees with checkboxes :-)</li>
      </ul>
      </p>
      
      <hr/>
      <a name="Release_Notes_1_1_10"></a>
      <h2>Release Notes for 1.1.10</h2>
      <p/>
      <h3>Fixed Issues</h3>
      <ul>
        <li>Normalized behavior of GWT.getModuleBaseURL() with respect to hosted mode, web mode, RPC, and automatic resource injection
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/6c2b23e90008b6b9">post #1</a>,
         <a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/1bb47f2cff671ef0">post #2</a>,
         <a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/3408c38464c57d4a">post #3</a>]
        </li>
        <li>Clarified message in Grid class related to row/column out of bounds error
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/e5e130cba766d126">post</a>]
        </li>
        <li>i18nCreator fixed to work with Java 5.0
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/3b6452a068ebec63">post</a>]
        </li>
        <li>I18NSync (and therefore -i18n scripts) changed to replace dots with underscores when generating method names
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/6a4e05beb094a5a2">post</a>]
        </li>
        <li>Additional character escaping in JSON strings
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/5f437d12ba83fff0">post</a>]
        </li>
        <li>Fixed bug calling toString() on nested JSON objects
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/ee81aa5411dece71">post</a>]
        </li>
        <li>Fixed bug that caused the default font size of text in a FocusPanel to be zero
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/2f5abf147c5550c4">post</a>]
        </li>
        <li>Fixed TabPanel.insert() with asHTML argument
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/8f427dbe76ce2c49/">post</a>]
        </li>
        <li>Popups and DialogBoxes no longer underlap lists and combos in IE6
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/6815ec29d2c404e2">post</a>]
        </li>
        <li>DialogBoxes can no longer be dragged beoynd the upper left corner of the browser window
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/28390f32c42f7940">post</a>]
        </li>
        <li>Buttons inside of FormPanels no longer automatically submit on Firefox; this is still a problem some versions of Safari and Opera
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/72bea3a6d4feeaeb">post</a>]
        </li>
        <li>TabPanel now sets the height of the internal DeckPanel to 100% to ensure all available space is used
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/4cd09f04bc515696">post</a>]
        </li>
        <li>Fixed bug in Mozilla that was causing DialogBox.onKeyPressPreview() to see key as 0
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/8147b4b219a8fbc7">post</a>]
        </li>
        <li>DockPanel no longer lays out with a DeferredCommand; this makes it possible to correctly measure the size of PopupPanel
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/7bbb89e4c97ae1e6">post</a>]
        </li>
        <li>SimplePanel is no longer abstract
        </li>
        <li>Double click now fires correctly on IE6
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/2d16242dc7fb830f">post</a>]
        </li>
        <li>Fixed RPC bug that caused deserialization errors or infinite loops with self-referential object graphs
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/2a8658e93e2a8de3">post</a>]
        </li>
        <li>Fixed RPC bug that caused deserialization to fail on character arrays containing null characters
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/f60f5d5552a3d26b">post</a>]
        </li>
        <li>Serializable classes whose superclass is serialized by a custom field serializer are now correctly deserialized on the server
        </li>
        <li>Fixed bug related to FocusPanel that sometimes manifested during RPC async responses
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/edd16ede4f891db8">post</a>]
        </li>
        <li>Fixed bug in JUnit assertEquals() for floating point values (delta was not honored correctly)
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/b0e06cc253915b86">post</a>]
        </li>
        <li>Fixed internal compiler errors related to nested local subclasses, empty for loop expressions, and no-op unary plus operator.
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/d8ecf70acc4e5b0e">post #1</a>,
         <a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/4da8dcbab9479a80">post #2</a>,
         <a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/a9f17bf30d0116b">post #3</a>]
        </li>
        <li>Fixed infinite loop in Integer.toHexString()
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/3f9c3f4df08fb523">post</a>]
        </li>
        <li>Compiler now handling filesystem symbolic links in project structure
        [<a href="http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/1597c73888d1acd9">post</a>]
        </li>
        <li>Fixed rare JVM crash in Windows hosted mode related to JSNI function pointers
        </li>
      </ul>
      
      <hr/>
      <a name="Release_Notes_1_1_0"></a>
      <h2>Release Notes for 1.1.0 (RC)</h2>
      <p/>
      <h3>New Features</h3>
      <ul>
        <li><b><a href="doc/html/com.google.gwt.user.client.ui.FileUpload.html">FileUpload widget</a></b><br>The much-requested file upload widget
        </li><li><b><a href="doc/html/com.google.gwt.user.client.ui.FormPanel.html">FormPanel widget</a></b><br>Easily submit traditional HTML forms from GWT apps
        </li><li><b><a href="doc/html/com.google.gwt.doc.DeveloperGuide.RemoteProcedureCalls.html">RPC optimizations</a></b><br>Client and server performance improvements and a more compact wire format
        </li><li><b><a href="doc/html/com.google.gwt.doc.DeveloperGuide.Fundamentals.Modules.AutomaticResourceInjection.html">Automatic Resource Injection</a></b><br>Modules can contain references to external JavaScript and CSS files, causing them to be automatically loaded when the module itself is loaded
        </li><li><b><a href="doc/html/com.google.gwt.doc.DeveloperGuide.Internationalization.html">Internationalization</a></b><br>Easily localize strings and formatted messages
        </li><li><b><a href="doc/html/com.google.gwt.xml.client.html">XML classes</a></b><br>An XML library based on the W3C DOM
        </li><li><b><a href="doc/html/com.google.gwt.json.client.html">JSON classes</a></b><br>JSON has moved into <code>gwt-user.jar</code>, and it's much faster than the sample that shipped with 1.0.21
        </li><li><b><a href="doc/html/com.google.gwt.doc.DeveloperGuide.JUnitIntegration.html">JUnit enhancements</a></b><br>Unit tests are much, much faster than in 1.0.21, easier to configure, and you can now test asynchronous things like RPCs and timers
        </li><li><b><a href="doc/javadoc/index.html">Javadoc</a></b><br>Now included for your convenience, with sample code fragments
        </li><li><b><code>gwt-servlet.jar</code></b><br>Although you should continue to build against <code>gwt-user.jar</code> as always, 
        you only need to deploy <code>gwt-servlet.jar</code> with your webapps; it contains the subset of <code>gwt-user.jar</code> you'll need to support RPC
      </li></ul>
         There are also a significant number of bug fixes from all the great feedback we've gotten from the developer forum. 
         Please see the <a href="#Release_Notes">additional release notes</a> for detailed information about other important changes in
         Google Web Toolkit since the previous release, including a few breaking API changes that we don't want to catch you off guard.
      </p>
      
      <h3>Fixed Issues</h3>
      <ul>
        <li><a href="http://code.google.com/webtoolkit/issues/4794724.html">Issue #4794724 - Servlet container problems due to gwt-user.jar including javax.servlet classes</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/1676686.html">Issue #1676686 - Hosted mode problems in Windows 2000</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/6606675.html">Issue #6606675 - ListBox and Image widgets are missing CSS style names</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/5922226.html">Issue #5922226 - Casts from interface types to concrete class types can fail</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/4137736.html">Issue #4137736 - Referencing an outer local from a field initializer causes NullPointerException</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/2518888.html">Issue #2518888 - Problem with "return" statements in constructors</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/9984353.html">Issue #9984353 - Hosted Mode server throws IllegalArgumentException when system is set to non-english locale</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/3733199.html">Issue #3733199 - Shrinking Grid via resizeRows() leads to inconsistent state</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/7659250.html">Issue #7659250 - Hosted mode on default Fedora Core 5 complains of missing libstdc++.so.5</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/6531240.html">Issue #6531240 - Empty if, while, do, and for statements cause Compiler Error</a></li>
        <li><a href="http://code.google.com/webtoolkit/issues/4927592.html">Issue #4927592 - Multiple initializations in for loop initializer causes internal compiler error.</a></li>
      </ul>

      <p>See the <a href="#Appendix">appendix of fixed issues</a> for the nitty-gritty list of things that we have fixed in this release, including smaller issues.</p>

      <h3>Behavioral Changes</h3>
      <p>Important changes in the behavior of existing GWT features.</p>
      <h4>Module Source and Public Paths</h4>
      <ul>
        <li>In previous versions of GWT, source and public path inclusions were based on physical
        directory structure; only files physically located with the module would be included. Going
        forward, source and public path inclusions are based on logical package structure. Once a package
        has been included, any files in that package become visible no matter where they are physically
        located.
        </li>
      </ul>
      <h4>JUnit Modules</h4>
      <ul>
        <li>GWT test modules (that is, modules intended to run GWTTestCase-derived JUnit test cases) no longer
        need to inherit the <code>com.google.gwt.junit.JUnit</code> module. Additionally, it is no longer an
        error to declare entry points within a test module (they will be ignored when running under JUnit).
        Most test cases can now simply use the existing application module, which should simplify test case
        configuration.
        </li>
      </ul>

      <h3>Breaking API Changes</h3>
      Based on user feedback, we've made a few API changes in this release that may require minor tweaks to your existing code when you upgrade.
      Any such changes that affect you should only take a few minutes to rectify.

      <h4>com.google.gwt.user.client.ui.HasWidgets</h4>
      <ul>
        <li>We've moved add(), remove(), and clear() into this interface, so that any widget that can contain other widgets will be bound to this contract.</li>
        <li>The add() method no longer returns a boolean.  If a panel either cannot add a child widget without extra arguments, or cannot accept further widgets, it will throw an exception.  This is in keeping with the fact that this is usually the result of an error in the code.</li>
        <li>Its iterator is now required to support the remove() method.</li>
      </ul>
      <h4>com.google.gwt.user.client.ui.Composite</h4>
      <ul>
        <li>Composites must now call initWidget() in their constructors, rather than setWidget().  This is more indicative of its actual purpose, and also serves to clear up any confusion with SimplePanel's setWidget() method.  Composite.setWidget() is now deprecated, and will be removed at the end of beta.</li>
      </ul>
      <h4>com.google.gwt.user.client.ui.SimplePanel and subclasses</h4>
      <ul>
        <li>
        We have added setWidget() to SimplePanel, which has more appropriate semantics for a panel that can contain only one child.  
        The add() method is still present through the HasWidgets interface, but will fail if a widget is already present.  
        This change is most likely to affect you if you use DialogBox or PopupPanel. To fix it, simply change your call to add() to setWidget() instead. 
        </li>
      </ul>
      <h4>com.google.gwt.user.client.Cookies</h4>
      <ul>
        <li>Cookies.getCookie() is now static, as it should have been from the beginning.  There is no need to instantiate this class now.</li>
        <li>You can now set cookies as well!</li>
      </ul>

      <a name="Appendix"></a>
      <h3>Appendix: Complete List of Fixed Issues</h3>

      <p>
        The list of issues below is a short synopsis of all of the major and minor issues fixed in this release.  
        See the <a href="http://code.google.com/webtoolkit/issues/">online GWT issues database</a> for the important common issues.</p>
      <ul>
        <li>String.matches(regex) should exist and doesn't</li>
        <li>Need a way to set individual List items selected/unselected (applies to multi-select listboxes)</li>
        <li>DOM needs setBooleanAttribute, getBooleanAttribute.</li>
        <li>HTMLTable.CellFormatter needs getStyleName() to match setStyleName().</li>
        <li>FlexTable's internal widget map does not correctly adjust for the user inserting rows and cells.<br></li>
        <li>Window.getTitle/setTitle should be static</li>
        <li># characters in filenames cause compilation to fail.</li>
        <li>DynaTable has incorrect HTML</li>
        <li>Change Timer API to use int not long</li>
        <li>In hosted mode JSNI, marshall Java longs as VT_R8 </li>
        <li>Popups are not always positioned properly on Safari.</li>
        <li>SWT source inclusion is wrong.</li>
        <li>Safari crashes on exit under some circumstances.</li>
        <li>TreeLogger throws away exception info in console mode.</li>
        <li>Window needs a private ctor</li>
        <li>Phone home version checking should actually compare ordering of version number</li>
        <li>Hosted Mode server throws IllegalArgumentException when system is set to non-english locale</li>
        <li>Trees have an unsightly 16-pixel left margin.</li>
        <li>SimplePanel.remove() broken.</li>
        <li>ScrollPanel doesn't implement SourcesScrollEvents.</li>
        <li>Make junit-web output to www dir</li>
        <li>Add "hidden" feature to ArgHandler system.</li>
        <li>JUnitShell could hang forever.</li>
        <li>1.5 VM fails to run junit because StackTraceElement 0-arg constructor disappeared.</li>
        <li>Panel and ComplexPanel still have methods from old version of HasWidgets.</li>
        <li>Nested tables can fire events from the wrong one.</li>
        <li>Make sure JSNI refs to functions can be passed around and used as real function pointers.</li>
        <li>AbsolutePanel doesn't position its children consistently.</li>
        <li>JSONParser does not handle generic JSONValues in the encoded json string correctly; always assumes its a JSONObject</li>
        <li>Remove -notHeadless from GWTShell (only applies to GWTUnitTestShell)</li>
        <li>Number of results returned from split() differs in Java/JavaScript (see description)</li>
        <li>Helper scripts don't work for base package.</li>
        <li>Grid fails to update row count when removing.</li>
        <li>JSONString, toString does not enclose its characters in double quotes</li>
        <li>Selection issue when removing widgets from TabPanel.</li>
        <li>JSONParser always assumes root type is JSONObject</li>
        <li>ClassSourceFileComposer should not handle Class objects.</li>
        <li>Modules cannot supercede files from inherited modules</li>
        <li>Simple &amp; ComplexPanel shouldn't implement getChildCount(), getChild(), etc.</li>
        <li>Negative byte values passed into JavaScript become positive</li>
        <li>The rpc servlet needs a thread-local HttpServletResponse to match the thread-local request.</li>
        <li>Appending char to a String behaves incorrectly.</li>
        <li>Remove STL dependency from gwt-ll</li>
        <li>Using xhtml doctype causes popups to be misplaced on Mozilla browsers.</li>
        <li>JsniInjector fails to match lines when there are Javadoc comments.</li>
        <li>Add whitelist bypass for hosted browser</li>
        <li>PopupPanel example is wrong.</li>
        <li>UIObject needs a title property.</li>
        <li>JSNI methods in local classes don't work in hosted mode.</li>
        <li>HashMap throws a JavaScript error under some circumstances.</li>
        <li>Source and Public module tags should be logical instead of physical.</li>
        <li>Document that module source and public tags are now logical rather than physical.<br></li>
        <li>Default .launch file fails to use project's full classpath.</li>
        <li>RemoteServiceServlet sends back HTTP 200 OK but no content under WebSphere.</li>
        <li>Widget.onLoad() is called too early sometimes.</li>
        <li>Is it really a good idea to have add(Widget) on Panel?</li>
        <li>Web-mode JUnit that reports via RPC</li>
        <li>Tree fires onTreeItemStateChanged twice.</li>
        <li>Make JSON APIs part of gwt-user.jar</li>
        <li>Async JUnit</li>
        <li>String.equalsIgnoreCase(null) throws exception in web mode</li>
        <li>Using a class literal for a pruned typed causes ICE</li>
        <li>Make all built-in implementations of HasWidgets.iterator() support remove().</li>
        <li>JSON is slow in Web mode</li>
        <li>StringBuffer uses string concatenation, and is n-squared as a result</li>
        <li>Identical Strings can compare false in web mode.</li>
        <li>Tweaks to the property provider environment to support locale and improve code uniformity b/w hosted and web mode<br></li>
        <li>Server-side serialization is unusably slow for large data sets</li>
        <li>Client side serialization is unusably slow for large datasets</li>
        <li>Format source for JUnitTestCaseStubGeneratorm, ServerSerializationStream</li>
        <li>MethodDispatch not working correctly on IE.</li>
        <li>JavaScriptObject rescuing is incomplete.</li>
        <li>Reduce RPC wire size by not quoting non-strings.</li>
        <li>Cyclic object graphs can be corrupted during deserialization on the server</li>
        <li>Test methods that throw checked exceptions cause the generated code to fail to compile</li>
        <li>Allow RemoteServiceResponse compression to be controlled by subclasses</li>
        <li>Startup timing bug makes RootPanel.get(id) throw an NPE</li>
        <li>Change whitelist/blacklist settings to be command-line switches rather than system properties</li>
        <li>KeyCode is always 0 for keypress events on Mozilla.</li>
        <li>Add Panel.remove(int) convenience method.</li>
        <li>File Upload Widget</li>
        <li>PopupPanel needs to deal better with being empty.</li>
        <li>CheckBox.setEnabled() has reversed sense.</li>
        <li>History tokens have problems with URL encoding.</li>
        <li>Loosen restriction on when DockPanel.CENTER child may be added.</li>
        <li>AbsolutePanel needs getWidgetLeft() and getWidgetTop().</li>
        <li>Decision: how should FlowPanel behave?</li>
        <li>Samples with composites need to call initWidget() instead of the deprecated setWidget().</li>
        <li>RootPanel.get(String) should not be clearing the div's contents.</li>
        <li>ListBox, Image, and Hyperlink are missing style names, despite doc</li>
        <li>Hyperlink.removeClickListener is broken.</li>
        <li>Don't allow tabs to word-wrap internally on TabPanel</li>
        <li>Turkish locale problem with the RPC generated code - probably affects others too</li>
        <li>StackPanel.add() totally screwy.</li>
        <li>Referencing a field that could cause static initialization fails to cause a side effect.</li>
      </ul>

      <hr/>
      <a name="Release_Notes_1_0_21"></a>
      <h2>Release Notes for 1.0.21</h2>
      <p/>
      <h3>Fixed Issues</h3>
      <ul>
         <li><a href='http://code.google.com/webtoolkit/issues/5823700.html'>Issue #5823700 - GWT hosted mode does not work when IE 7 is installed</a>
         <li><a href='http://code.google.com/webtoolkit/issues/8840603.html'>Issue #8840603 - GWT applications do not run in IE 7</a>
         <li><a href='http://code.google.com/webtoolkit/issues/3844117.html'>Issue #3844117 - Cannot reference a final local variable from a deep inner class</a>
         <li><a href='http://code.google.com/webtoolkit/issues/9157420.html'>Issue #9157420 - Compiler reports errors for non-ASCII characters (UTF-8 not supported)</a>
         <li><a href='http://code.google.com/webtoolkit/issues/1524429.html'>Issue #1524429 - RPC exception due to empty strings</a>
         <li><a href='http://code.google.com/webtoolkit/issues/6000056.html'>Issue #6000056 - ArrayStoreException initializing multi-dimensional arrays</a>
         <li><a href='http://code.google.com/webtoolkit/issues/3490506.html'>Issue #3490506 - Tree widget remove() bug</a>
         <li><a href='http://code.google.com/webtoolkit/issues/8201889.html'>Issue #8201889 - Generated RPC proxy code fails to pull in String intrinsically</a>
         <li><a href='http://code.google.com/webtoolkit/issues/1600857.html'>Issue #1600857 - TabPanel getWidgetIndex() recursion</a>
         <li><a href='http://code.google.com/webtoolkit/issues/2705290.html'>Issue #2705290 - TabPanel widget does not remove tabs properly</a>
         <li><a href='http://code.google.com/webtoolkit/issues/9377889.html'>Issue #9377889 - TabBar method insertTab() not honoring 'asHTML' parameter</a>
         <li><a href='http://code.google.com/webtoolkit/issues/4387606.html'>Issue #4387606 - FlexTable and Grid issues</a>
      </ul>
   </body></html>
