If you ever wanted to meet a whole bunch of qooxdoo core developers at once, there's a good chance to do so on May 26-28, 2008: Two conferences will be held in the city of Karlsruhe (Germany), where most of the qooxdoo framework developers work at 1&1. Excitingly, many team members will participate in the event as speakers, covering quite a wide range of topics, including brand new qooxdoo 0.8 features as well as modern web technologies in general.

Both conferences take place at the same time and location. The first one is the webinale, a well-known German web conference. Most of the talks will be given in German, and so will the following (titles translated to English):

Two power workshops (3 hours each) will focus on features and tools of the upcoming qooxdoo 0.8:

• GUI Development with qooxdoo (Sebastian Werner, Fabian Jakobs) - in German
• Advanced Web Application Development (Sebastian Werner + other core developers) - in German

A session within the "RIA day" track will show how qooxdoo stands up to other technologies:

• qooxdoo - Killer apps for all browsers (Andreas Ecker) - in German

Dynamic Languages World Europe is the first European conference dealing with the shared concepts and frameworks of all important dynamic languages. Of course, we made sure that JavaScript is in the mix. This is an international conference with all the sessions given in English:

• Advanced Object-Oriented JavaScript (Andreas Ecker) - in English
• Selenium RC: Automated Testing of Modern Web Applications (Thomas Herchenröder) - in English
• JavaScript Tooling - Minimize, Lint & Co (Fabian Jakobs) - in English

A great opportunity (at least for the German qooxdoo community) to meet us at these conferences, getting a fair amount of qooxdoo overdose and hanging out with us for a beer or two. If you are interested, let us know. 

Tomorrow is a national holiday here (May 1st), so the qooxdoo core developers at 1&1 will take the opportunity for a decently long weekend. We'll be back next Monday. Of course, we won't leave without providing our weekly status update, so here are the most prominent changes (only accounting for the last 3 days!):

qooxdoo 0.8 GUI toolkit

• The API documentation for the new layout namespace was completed. Hurray. Finally, the best documentation of layout managers we ever had. So hopefully it is much easier for you to work with the new layout system.
• Introduced caching to the layouts HBox, VBox and Dock in order to improve their overall performance. Especially for reflow situations where the outer dimensions changed.
• Added support for margins to the layouts HBox, VBox, Dock, Canvas, Basic and Grow. HBox and VBox support the concept of margin collapsing as well. Negative margins are also possible in all mentioned layouts except the Grow layout. The margin is a property of each layout item, so every layout should respect the margin property accordingly.
• The Dock layout supports the new margin property (as mentioned) and introduces support for horizontal spacing and vertical spacing. These allow to add grid-like customizable separators to the layout.
• Major rework of alignment support. Both box layouts now support alignment for each axis, when set directly on the layout. They also respect the individual alignment properties as configured on the layout item itself (which have a higher priority than the values on the layout itself).
• All supported layout properties are now validated by the layout managers. This means that unsupported values or their combination trigger immediate developer feedback using exceptions.
• The selection handling on the List widget was fixed.
• Focus handling for complex nested widgets like the Spinner was improved. The focus style should work for these with the latest revision as well.

qooxdoo 0.8 Build process

• Generator2: There was a major overhaul of the wiki page for the generator config files. The old tabular view for the various config keys was - albeit good looking - neither easy to read nor to maintain. Keys were easy to look up, but then lacked context, so sub-keys were hidden under the main keys in an unintuitive (and less expandable) way. The old table now only holds an overview listing for quick orientation, and the real documentation of the config keys is done in a nested list structure that represents the various contexts. We are aware that the whole issue around the new generator's configuration is a learning hurdle, so any comments on readability and accessibility of this piece of documentation are warmly welcome.

qooxdoo-contrib

• HtmlArea: Inital work on porting the widget to the upcoming qooxdoo 0.8 version began. We fixed some glitches which were reported on the mailing list (thanks to Hugh, Siarhei and Dietrich) and improved text formatting support for Webkit.

Contribution of the Week

• Thanks to our fellow framework developer Derrell Lipman, there is cool contribution, which is both educational and entertaining. From his post to the mailing list: "For a long time, I've been wanting to write a somewhat more practical example of using the Finite State Machine module in qooxdoo. A mouse solving a maze maps very well to a Finite State Machine. Each mouse is driven by a finite state machine. I actually derived the Mouse class from the FSM class in this case. This example demonstrates only a small part of the capability of qooxdoo's FSM implementation, so look at the FSM documentation for more info". Enjoy the example that has been checked into the demobrowser of the 0.7 development branch as FsmMiceMaze!

For quite a long time now qooxdoo-contrib includes a WYSIWYG html editing widget called HtmlArea. During the last few weeks Jonathan and I have been busy improving the existing widget, and have now released a new version.
Since there are many other open source projects around with a similar technical approach, why haven't we just picked one of those and ported them to (or just used them with) qooxdoo? Well, we think we have a slightly different focus and goal in mind than the other projects: We wanted to create a solid, clean cross-browser widget, focusing on a fundamental set of functionality rather than a full-blown WYSIWYG editor. HtmlArea intends to support all the four major browsers that include basic html editing capability in their most recent versions. Well, to be fair, that is a long-term goal, with IE and Firefox currently getting more love than Safari or Opera.

Today we released a new version HtmlArea 0.2 with the following features:

• Text formatting
  • font family
  • font size
  • font weight
  • text decoration
  • font style
  • text color
  • background color
  • text indention
• Complete Undo / Redo handling
• Insertion of HTML elements
  • table
  • image
  • list
  • horizontal ruler
• Easily expendable to insert custom HTML

See a simple live demo.

In a future release we would like to include some kind of plug-in architecture which would allow for an easier development of extensions to HTMLArea. We also think about different feature sets (e.g. basic, simple and advanced) for different users' needs. Please also note that one of the next versions will target qooxdoo 0.8 and might not work with previous qooxdoo versions.

Let us know what you think about HtmlArea so far. The infrastructure of qooxdoo-contrib allows anyone to contribute to qooxdoo quite easily - either by collaborating on existing features or on starting and maintaining new ones.

Here it is again the weekly status update, quite a bit this time, mostly addressing progress in qooxdoo 0.8 development:

• generator2: We have introduced "Manifest" files into the configuration process. Manifest.js files have been around for a while in qooxdoo-contrib projects. They serve to provide meta information for the project in a structured way. We have now extended this initial Manifest file layout to include technical data that can be used automatically by the build process. You will find those new Manifest files increasingly in the trunk version of the standard qooxdoo applications, demobrowser and apiviewer taking the lead. config.json files can now incorporate "libraries" without (re-)specifying their internals like their encoding and paths to classes and resources. Consequently, the new "library" key only takes the path to the relevant Manifest.js file, and an URI prefix to the respective directory. You probably guessed what this is all supposed to end up with: skeleton-structured "libraries" can provide their features through a uniform Manifest file, be they a straight library like the qooxdoo framework, a tool add-in like the API viewer application, or a component contribution like the Inspector, for other projects to use. If you are working with the trunk version of the qooxdoo SVN repository, please update your config.json file accordingly because the old "library" entries will not work anymore. (Gee, we need to update the documentation ...).
• This week we spent some time to hang out with the guys from Innoopract. They have started to play and work with the upcoming 0.8 version of qooxdoo more intensively. They have already provided a lot of valuable feedback and discussion about things like child widget handling and widget pooling. Their high-profile RAP project gives them a very sharp eye for the nuts and bolts of the next qooxdoo version. We also raised a glass of beer or two
• Support for margins have been introduced at widget level. This means that margin is a property which every layout manager should respect. Earlier, the margin property was only implemented on box layouts, but it will soon be introduced into other layouts as well. Have a look at the box layouts as they are the first feature-complete layouts following all our latest API ideas.
• An experimental layout property editor has been added to most of the layout demos. This editor can be used to inspect and change all layout relevant properties of a widget. A widget can be selected for editing by simply clicking on it



• Alignment support for widgets is now available on the LayoutItem. The newly introduced alignX and alignY properties should be respected by any layout manager and have a higher priority than other alignment values given directly to the layout manager. This feature is now fully supported by the improved box layouts as well. Other layout managers will follow.
• Some layout algorithms were greatly improved. For example, the flex compution is much more efficient now. The box layouts also have got some tweaks to reduce re-parsing of complex values (e.g. percentage values).
• The decorator implementation has been modified to allow more fine-grained update routines. For instance a decorator gets information about changes like size, background color or the overall style. This may result in faster updates when all decorators make use of this new data.
• The generic renderLayout method in LayoutItem was greatly improved. The new version reduces updates to the DOM "backend" to a large extend by evaluating if modifications have any influence on certain aspects.
• Many structural improvements to the LayoutItem / Widget combination where made. A lot of stuff has been split out and moved around to have the implementation in the responsible class. Compared to the previous implementation the Widget itself has a lot less knowledge about the general layouting interface.
• New contributions appeared in qooxdoo-contrib: "FileSize" includes a filesize format class and corresponding cell renderer. FilesizeFormat enables the conversion of 500 to 500kb, 1500 to 15 KB, etc.  The Filesize cellrender enables data formatted as Filesize to be included in a table. Thanks to Mike Rea for this contribution! Haven't you got something you'd like to share with other qooxdoo users? Please check out the infrastructure of qooxdoo-contrib that makes it very easy to start, maintain and collaborate on additions to qooxdoo.

Children Handling

Children handling in the qooxdoo 0.8 development branch has been completely refactored. After some discussion on the mailing list we decided to move the widget children handling from the layout managers back into the widgets. Initially we have adopted the "Qt approach": Each widget with child widgets needs a layout manager to maintain the child list and to position the children. Children were added only to the layout manager. This has been changed back to the more "traditional" approach, where the children list is maintained by the parent widget. A layout manager can optionally be used to position the parent's children. The main reason for this change is that it makes it easier for people to build up the widget hierarchy in a generic way without knowing the layout managers used. Such an approach is needed e.g. by the Eclipse Rich Ajax Platform (RAP), or other frameworks on-top of qooxdoo like qxTransformer, and also by GUI builders, etc.

Generator2

Some new features have been added to the new generator2:

• Support for image slicing and combining in generator (triggers 'slice-images' and 'combine-images' [*]); "*-combined.png" images and their corresponding ".meta" files are showing up in SVN. The functionality is based on tools from ImageMagick. Combined images are used within qooxdoo for e.g. decorators.
• New #asset() compiler hints can now include macro references which are defined in the config.json file; this can be used to e.g. vary over themes [*].

General

Some user-supplied patches went into the qooxdoo user extension for Selenium.

To make it easier to follow the often fast-paced development of qooxdoo, we try to establish a summary of activities on a weekly basis. This is a first wrap-up of this week's updates in the qooxdoo world:

qooxdoo 0.8:

• Cross-browser focus and tab handling implemented, both low-level at the DOM and high-level at the widget system.
• ScrollBar widget to replace native scrollbars already used in List and Tree widgets.
• New qooxdoo theme: See a first demo
• Generator: config.json for framework and general application, 'api' job running in framework; initial support for image slicing and combining; updated generator config page

General:

• qooxdoo-contrib: heavy work has being done on HtmlArea and qcl.
• If you haven't tried out yet, do so: QWT - the qooxdoo Web Toolkit (similar to GWT)
• qooxdoo-specific support for the Eclipse IDE is coming. Stay tuned for an early preview of the qooxdoo Development Toolkit, which is expected to be available soon...

The generator, heart of qooxdoo's tool chain, has been overhauled extensively for 0.8, close to a complete rewrite. Main objectives for the new implementation include

• support for parts
• run multiple jobs "in one go"
• replace "make" and other GNU/Unix tools as far as possible, to cut down on prerequisites
• support a unified application/library structure throughout the project
• pave the way for an enhanced GUI-based build tool

The first and maybe most visible change the new generator brings for the users is the changed configuration. The current tool chain relies heavily on GNU's make, deploying various related Makefiles. The primary means to configure the build process is through Makefile variables. The new generator replaces these make tools with config files that are based on JSON, a data format that blends well with both Javascript and Python.

The challenge here was to use JSON's basic declarative syntax elements like dictionaries (maps), arrays and simple data types, and build upon them a semantics that is both rich, to provide a sufficient level of power and abstraction, and generic, to cover all necessary use cases. (It almost feels like defining a new XML schema...).

The current state of the issue is that a config file contains a single big map that keeps a varying number of keys that represent jobs. A job can be anything from copying files around to generating the build version of an application or its API documentation. Consequently, jobs deploy certain keywords to trigger those actions, along with necessary configuration data like where to look for source classes, where to place outputs, where to find resources, and so forth. To foster re-use (and limit unnecessary typing), config files deploy three basic mechanisms: They can include other config files, and jobs can "extend" each other (This works a bit like inheritance between classes; the parent job's settings are merged into the current job, which can add new settings or override some of the parent's settings). The third tool are string macros that are expanded in other strings in the config.

For the curious who want to get their feet wet and their hands dirty, the generator2 config page provides a lot of further stuff to read and ponder. Feedback welcome.

In our constant quest for cross-platform compatibility we are especially proud to announce support for the legendary Netscape Navigator 4 browsers with qooxdoo 0.8. This browser, in its latest stable 4.08 release, has had a major impact on Internet usage and browser experience, and still maintains a small but die-hard community of users (Netscape's shares of the browser market total at about 0.68%).

This is another step forward to show qooxdoo's commitment to real world technologies and to help protect existing investments. We are particularly happy to present qooxdoo support for this platform in the 10th anniversary of its most recent release.

Happy Birthday, Netscape 4!