<!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">1.3 Release Candidate (@GWT_VERSION@)</a></li>
		    <li><a href="#Release_Notes_1_2_22">1.2 Release (1.2.22)</a></li>
		    <li><a href="#Release_Notes_1_2_11">1.2 Release Candidate (1.2.11)</a></li>
		    <li><a href="#Release_Notes_1_1_10">1.1 Release (1.1.10)</a></li>
		    <li><a href="#Release_Notes_1_1_0">1.1 Release Candidate (1.1.0)</a></li>
		    <li><a href="#Release_Notes_1_0_21">1.0 Release (1.0.21)</a></li>
      </ul>

      <hr/>
      <a name="Release_Notes_Current"></a>
      <h2>Release Notes for 1.3 Release Candidate (@GWT_VERSION@)</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 Release (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.
      
      <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 Release Candidate (1.2.11)</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.
      
      <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 Release 1.1 (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 Release Candidate (1.1.0)</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 (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>
