qooxdoo 0.8.2 is a solid maintenance/bugfix release. It also includes additional functionality, often as an experimental preview. It is recommended that users upgrade their existing applications to this latest stable version.

Please read the migration notes at the end of this document carefully. A few manual steps may be required for properly upgrading to this release and the latest web browsers.

• Inspector, a cross-browser debugging tool a la Firebug
• Tons of improvements and bugfixes over the previous version
• Tested for all common browsers, including upcoming versions like IE8
• Optimized packaging and loading of qooxdoo applications
• CSS3 selector engine and a jQuery-like low-level API
• Preview of the upcoming data binding layer
• Preview of the new infrastructure for virtual widgets

• Key event handling again showed its ugly face. An old Firefox bug reappeared in a different place and had to be fixed.

• A namespace qx.type has been created to contain qooxdoo classes, which can be used to sub class native JavaScript types like String, Error or Array. The classes prefixed with Base are designed to be used as base classes for custom classes. In addition there is a qx.type.Array class, which is a sub class of the native JavaScript array, but adds convenience functionality found in qx.lang.Array. It is expected to complement this with a additional classes like qx.type.String and qx.type.Number in future releases.

• Some classes, particular in the qx.lang namespace, got a review and additional methods were added to make them even more convenient.

• The advanced qx.io2.ScriptLoader now works fine in Internet Explorer as well.

• Performance was improved for the event handling and managing code, mostly by reducing the number of function calls.

• Improved memory management (e.g. correctly detaching events in IE) and object handling, working around some IE peculiarities.

• Significant changes have been made to the way qooxdoo applications start up. The JavaScript code of the loader script has been simplified and the code chunks responsible for the part loading logic have been move into regular framework classes.

• Furthermore the build version of a qooxdoo application now (again) only consists of a single JavaScript file (not two as in 0.8 and 0.8.1). The separate loader script for the build version is no longer needed. This especially helps to use qooxdoo in low-level applications.

• Another change was that qooxdoo now uses the DOMContentLoaded event to start up the application, which results in faster startup times especially in inline style applications.

• The changes to the startup process of qooxdoo applications revealed a problem in the WebKit rendering engine used for instance in Safari or Chrome. These browsers now require a body tag in the loader HTML file. Even if the body tag is empty, which is often seen for regular qooxdoo apps. Remember that this body tag has to be added manually to your existing applications in order to support those latest browsers.

• Confirmed support for Internet Explorer 8 RC1. qooxdoo runs in all modes (Quirk, IE7 Standard Mode and IE8 Standard Mode). The latest IE8 RC1, which was used at the release time, was lagging performance, particularly while handling mouse events. It appears to be an issue of IE8 RC1 and not qooxdoo. The issue appears to be known and fixed, so it is expected to ship with the final IE8 release.

• 0.8.2 saw one of the most comprehensive testing phases of any qooxdoo release. Including the following standard browsers: IE6, IE7, FF2, FF3, Safari 3.2, Opera 9.6, Chrome, as well as the “beta” versions IE8 RC1, FF3.1b, Safari 4 beta, Webkit nightly.

• qooxdoo now comes with a powerful built-in CSS3 selector engine. It integrates the independent Sizzle project, which is at the heart of many JS low-level libraries, most prominently jQuery.

• For typical low-level applications it is often advantageous to work with an entire set of DOM nodes at once. A new class called qx.bom.Collection allows to modify such a set (often the result of a CSS selection), apply new CSS styles, add events or insert content. It also extensively supports a jQuery-like coding style including the chaining concept. It largely builds upon the existing comprehensive low-level layer of qooxdoo (als called “BOM layer”), but offers an alternative or complementary API that is appealing for many web developers. This new collection based API is still experimental and not yet stable. See the preliminary feature comparison to jQuery, feedback is appreciated.

• Introduced new qx.bom.Html class for advanced preparation of HTML markup, currently only used by the new Collection class.

• Dimension API now includes two new methods getContentWidth() and getContentHeight(), which should be preferred in most cases over the previous simple browser-specific wrappers (like clientWidth() or scrollWidth()), which were deprecated.

• Re-introduced support for cookie handling by the class qx.bom.Cookie. This simple but convenient wrapper was missing in 0.8 and 0.8.1.

• The user agent string of Opera 10 is now parsed correctly. Testing for this early alpha version of Opera was not undertaken for this qooxdoo release, though.

• The FocusHandler instance is now available at page startup for low-level applications.

• The Inline root widget now connects to the global focus handler. Also a bug was fixed which let IE hang in an infinite loop while automatic resizing the root element was enabled.

• qx.application.Simple is now deprecated, use qx.application.Native instead.

• Native contextmenus are (again) hidden for all RIA-style applications.

• While implementing the selection managers for the virtual widgets, a couple of bugs have been fixed in the existing selection manager code.

• Tooltips and Menus now fully work in combination with an inline application. Also a menu is not closed anymore when the user clicks at a disabled menu item.

• If a SelectBox or ComboBox was added to a Scroll container and the view port was moved, the pop-up window was visible at all times, also when the corresponding SelectBox or ComboBox became invisible. To fix this issue, the pop-up window is now closed when the user scrolls the view port.

• The CheckBox had a different background color, if checked with the keyboard. Resolved now.

• Fixed problem with textfield widgets in IE at mouseover and mouseout events

• Fixed an issue, that prohibited the Spinner to accept the enter key as input.

• Before actually starting to work on the new infrastructure for virtual widgets most of the remaining open bugs for the current Table were fixed. These fixes not only account for better auto-sizing behavior of the table, they also helped to squish a number of smaller but nonetheless annoying bugs.

• An extension was also made to the Table widget. It now has a cleaner interface to the column visibility menu, including interface definitions (IColumnMenuButton and IColumnMenuItem) for authors wishing to create their own column visibility menus. One example of such an alternative menu is now available in qooxdoo-contrib as the TableColumnMenuGrid project.

• Moderately updated appearance of several form widgets (textfield, selectbox, splitbutton, slider, etc.) to better visualize the disabled state
• Updated some icons from the latest Oxygen checkout

• This release contains a preview of the new infrastructure for virtual widgets. This is still work in progress, but the first results are already very promising.

• In addition 0.8.2 features a preview of the upcoming data binding feature of qooxdoo. It has improved significantly since the early introduction in the 0.8.1 release. Nevertheless it is still in an experimental state and feedback is appreciated.

• One big topic during the development process were controllers. They are responsible for setting up and managing the connection from the data model to the view. Three controllers have been added so far:
  • Object Controllers for binding single values to views like textfields.
  • List Controllers for list-like widgets e.g. List and SelectBox.
  • Tree controllers for the Tree widget.

• Another topic is data stores. A store is responsible for fetching data (typically from an URL) and to transform it into a model of the application. The currently included store converts JSON data into a model, which can be used as model for the controller.

• More insight into qooxdoo’s data binding feature, with some more practical information can be found at the preliminary documentation.

• As a featured application of 0.8.2 the Inspector is back! Previously it was part of the contributions to qooxdoo 0.7.x, and now it has been ported to 0.8.2 and integrated with the framework.

• To get the basic idea, think of it as a cross-browser debugging tool a la Firebug for inspecting and tweaking a qooxdoo application. For instance it enables you to easily locate widgets visually and then modify them using a corresponding property window or a handy JavaScript console. Additionally you can examine the hierarchy of widgets of your user interface, or have an eye on qooxdoo’s central object registry.

• Even while lacking some of the cool features of its 0.7 predecessor, it is already such a useful tool for app development, that we wanted it to get baked into a release rather sooner than later. Certainly there is much room for improvement over the current version, nonetheless take advantage of it now, and stay tuned for all the enhancements to come.

• Improved performance of the syntax highlighting (for both HTML and JavaScript files) in Internet Explorer.

• Many new demos were added, e.g. for the Template util class or to showcase Localization.

• Less end-user relevant demos were moved to the test folder, obsolete demos were removed entirely.

• An autorun feature was added, which is most useful when being integrated with a build-and-test environment like the one used during 0.8.2 development.

• The feed reader has been updated to use qooxdoo’s part loading mechanism. The code for the Add Feed and Settings window will now be loaded on demand, which reduces the amount of code to be loaded at start up.

• The application was rewritten internally to demonstrate the practical use of the upcoming data binding features. Given the impressive intermediate results, this clearly shows how the future qooxdoo app development will benefit from this powerful and concise data binding layer.

• The portal application now uses qx.application.Native instead of qx.application.Simple

• Added a little helper popup to the search pane to give users hints about the search field. There might be more info on wildcards, etc. in the future, so this tiny helper may just be a start.

• Fixed HTML output to account for @see tags correctly.

• Autoscrolling to an entry like a property or a method given by URL now works again

• * Added new file index-source.html, to directly open Testrunner with the source version of the tests (use generation target test-source). This nicely supports test-driven development (TDD).

• Added support for asynchronous tests

• GUI enhancements: Stop button, log filtering, selective loading of test classes.

• Some memory leaks were also fixed.

• Simplified BOM skeleton on tooling side.
• Consolidated migration skeleton, which might be resolved into the regular GUI skeleton in a future release.

• It is now possible to generate a Inline skeleton application with the create-application.py python script
• New standard job inspector for custom applications (see Inspector further up).
• Standard jobs fix, pretty and lint now honor class filtering (i.e. “include”/“exclude” settings).
• The -v command line option to generate.py now also reports byte sizes of resulting class code on build jobs.
• File name handling is now case-preserving on Windows platforms; this is interesting if working with other case-sensitive apps on Windows, like standard Tomcat.
• Add support for complex library name spaces (e.g. org.qooxdoo.slc).
• Support for the new application loader mechanics.
• Re-structured compiler backend.

• Performance improvements for compile jobs through code optimization and cache utilization.
• Overhauled variable optimizer, fixing various bugs.

• Enhanced detection and reporting of unknown classes during class scanning.
• Improved the built-in JavaScript validation tool ecmalint.py.

• Improved parsing of Utf-8 source code (BOM, unicode white spaces).
• Various fixes to .po file handling (plural keys, utf-8 files, long comments, etc.).

• Added an Introduction to the SDK page.
• The API documentation of the existing animation feature in qooxdoo was improved and a chapter about this topic was added to the manual. The documentation describes the usage of animations on DOM elements, explains the effect queue and demonstrates how to implement own effects.
• New page about generator default jobs.
• New Snippets added, e.g. Activate the focus handler at low-level, keypress and keyup listener at input elements

• HTML files (typically index.html) that start-up a qooxdoo application need to contain a <body> element. Otherwise Webkit-based browsers like Safari and Chrome may fail. Unfortunately there’s no workaround available to fix this “on-the-fly”, so please make sure to add such a body tag in your application’s HTML file.

• The generate.py has been changed to automatically search for the SDK based on the QOOXDOO_PATH defined in the config.json. Since we are not able to migrate the generate.py with the migration script this file must be updated manually. To do this, the file must be overridden with the new version located at qooxdoo-0.8.2-pre-sdk/component/skeleton/gui/generate.tmpl.py before starting the migration task itself.

• A number of deprecations were made for methods in the framework code. A corresponding deprecation warning is displayed in an application’s source version when such a deprecated method is called. It contains some more info, typically pointing to the alternative method to use instead. The earlier you replace deprecated methods in your code the better, despite the fact that your app is expected to continue to run fine (even without deprecation warnings in the build version).

• The IDecorator interface has been changed to support use cases other than in qx.ui.core.Widget. Custom decorator classes have to be updated to the new interface.

• For more information about the usual migration steps please see the migration guides in the manual.