qooxdoo 0.8 - the next major release that includes an exciting rewrite of the GUI toolkit - will also offer a powerful animation layer with a wide range of effects. qooxdoo animation, as we call it, is to a large extent derived from the well-known effect library script.aculo.us.

To give you a small example, I will demonstrate how easy it is to build a typical One Second Spotlight in qooxdoo:
Imagine your website has an info box with the current number of your product's downloads:

Downloads today: <span id="dlAmount">10</span>.

Every time a user starts a download, a function should be called to update the box. Using the Highlight effect on the element containing the number of downloads, you can easily get the user's attention:

 
  var element = document.getElementById("dlAmount");
  var attention = new qx.fx.effect.core.Highlight(element);
 
  function update(amount)
  {
    element.innerHTML = parseInt(amount);
    attention.start();
  }

See the development version of the demobrowser for some early animation demos. Please note that the animation API might still change before the final 0.8 release. The current animation layer is a low-level DOM layer that will later also be used internally to animate the high-level qooxdoo widgets when they are available in 0.8.

With the recent release of Safari 3.1 the WebKit team has completely reworked the handling of key events. John Resig has an interesting blog article with some details. Safari 3.1 now behaves pretty much like Internet Explorer and is in general much more sane than before. For instance, all those strange key codes larger than 64000 for special keys are gone and finally modifier keys like "shift" and "control" fire key events as well. Interestingly, Safari is now the first browser to support the key identifier property defined in the DOM level 3 event specification. In qooxdoo we already emulate this property in key events for quite some time now, and it really helps to simplify key handler code in our widgets.

Unfortunately, this change in Safari 3.1 broke the existing qooxdoo key event handler. But it is already fixed and available in our subversion repository for legacy_0_7_x branch and trunk. The fix was basically to detect the current WebKit version and use the existing Internet Explorer key handler code also for Safari 3.1 and above. Since all browser quirks are handled separately this was a pretty simple fix. Of course, it will be part of the next minor release 0.7.4 as well as the final 0.8. If you need Safari 3.1 support now, please checkout the latest version from the legacy_0_7_x branch.

This article is for the theoretically inclined among us :-).

When putting together a JavaScript application order matters. Since the browser
evaluates JavaScript code in the order it arrives, every code that is referenced
by other code has to come beforehand, in order for that reference to succeed.
This for example affects calls to other functions within the body of a certain
function, since these references are resolved at load time by the interpreter.

The same holds true for the prototype reference used for a "derived" class
(constructor) object. The "ancestor" function has to be loaded before you can
use it as the prototype for another function.

In qooxdoo, classes are declared as maps which are passed to a
class-constructing method, qx.Class.define(). This method creates the basic constructor object, sets the prototype and other prototype properties, and so forth. It is only when qx.Class.define is actually executed that all referenced objects in the class definition have to be in place, the most prominent being the "extend" member of the class which names its parent class.

qooxdoo's generator goes to some length to assure that classes are constructed in the right order. This is reflected in the script/<application>.js file which contains a list to the appropriate class files (in the "source" version), or the actual class code (in the "build" version). Obviously, classes that serve as base classes for others have to come earlier. But this is not all there is to it. Classes not only inherit from other classes, they also use them, through creating instances of them in their own code or calling out to static functions. Whenever code that does that is evaluated those other classes have to be in place.

You probably already know where this is going to, there is a risk of circular dependencies. A simple example might illustrate that. Most classes in qooxdoo derive from qx.core.Object, e.g. the Logger class. But qx.core.Object itself might want to start logging early when it is created, that is "use" a Logger instance. Another typical example for complications of this kind is the 'tr' function that needs a qx.locale.LocalizedString, which might not be present at the time you call 'tr'. A point in the class declaration where this might crop up is the 'defer' section, which contains code that is actually run after the class has been constructed, but might include references to classes that are not readily present in the interpreter.

On a general level what we are looking for is a partial order on the set of qooxdoo classes, the relations in question being "require" (the other class is a parent class) and "use" (the other class is used in the code). The question is: Is there a partial order for the qooxdoo classes under the combined relation "require/use" where a class A "comes before" a class B exactly when A is required by B and/or A is used by B. Only if there is such an order can qooxdoo classes be sequenced consistently.

We are happy to announce a new release of the qooxdoo Web Toolkit. QWT is a qooxdoo-contrib project that provides an alternative, Java-only programming model for the qooxdoo JavaScript framework.

It allows you to create qooxdoo applications just by leveraging Java technology - no HTML, CSS, DOM nor JavaScript knowledge is needed. You can take full advantage of the typical Java IDE features (like auto-completion, etc.) while coding your application. The Java source code is automatically transformed into the qooxdoo JavaScript equivalent before deployment.

Version 0.2.0 of QWT features a simplified installation, MS Windows support and Reverse Ajax (a.k.a. Comet, still experimental).

Just download it, installation should be a piece of cake. For more information please have a look at the QWT documentation.

The project is still in its early stages, any of your feedback and contribution is appreciated. Have fun.

The upcoming AJAXWorld Conference & Expo is one of this year's premier events focusing on "rich web technologies and enterprise web 2.0". qooxdoo - being one of the few comprehensive frameworks that spearheaded the development of Ajax-based Rich Internet Applications - will be present at the event to showcase its features and vision.

If you ever wanted to know more about qooxdoo and meet some of the people behind this open-source framework, join us at the conference on March 18-20, 2008 in New York City. There will be a session on Next-generation AJAX Applications with qooxdoo, and we'll be available for discussion at the exhibition. Some of the framework core developers will be there (Fabian, Sebastian, Derell, myself, other qooxdoo users), so stop by at our booth, meet us the day before or after the conference or hang out with us at night.

We have just been offered some free expo passes that allow access to the Expo floor, vendor presentations, keynotes and power panels for the entire event. They are not full conference passes, so you won't be able to attend all sessions. Anyway, it's a great opportunity to attend AJAXWorld and meet us. If you are interested, just let me know (ecker AT users DOT sourceforge DOT net). Looking forward to seeing you at AJAXWorld!

UPDATE: Just added - The FREE passes are "Expo Plus passes" that allow access to TWO FREE technical sessions per day, March 19th and 20th! Just drop me a note if you're interested.