Backbase Enterprise Ajax 4.2 Client Edition brings many new features and improvements, ranging from CSS selectors to improved data binding and redesigned skins and Widgets. Please scroll down to read the details.

• Support for lightweight Ajax
• Improved data binding
• Adobe AIR Support
• Redesigned Chameleon Skin
• New and improved widgets
• Sample Application Layouts
• Improved Documentation
• Performance enhancements
• Other improvements

New: Support for Lightweight Ajax with CSS Selectors

To simplify Ajax development, Backbase uses a dual-DOM model. This means that you program against a simplified, cross-browser API (the ‘model space’), and the Backbase Client Runtime translates this to the real HTML DOM (the ‘view space’). This results in faster and more reliable development cycles, especially for complex Ajax applications.

When you want to add lightweight Ajax functionality to an existing web page, we recommend using the new Lightweight Ajax features. Lightweight Ajax is a single-DOM approach: you can use CSS selectors to select nodes in the ‘view space’ and then implement event handlers for DOM events. You do this by specifying the ‘match’ attribute on the event handler tag, so you can combine a CSS selector with an event handler. This technique makes it extremely easy to react to specific elements in the ‘view space’.

If you want to work in the ‘model space’ to enhance existing web pages, you can use enhanced HTML, which was already available in 4.1.2. With enhanced HTML you convert a section of your web page to the Backbase ‘model space’. This conversion takes a fraction of a second longer than Lightweight Ajax and it gives you a dual-DOM approach.

With these new features Backbase now offers an optimized solution for any Ajax programming task. Please refer to the documentation for further details.

Improved Data binding

In 4.1.2 we introduced Data Binding to populate widgets with XML or JSON data. In 4.2 we’ve added support for hierarchical data structures. This is required to support widgets that need such a hierarchical data structure, such as Tree and Menu. We now also provide a databound version of the Tree and Menu widgets (beta), using the new Data Binding functionality. This is in addition to data binding for existing widgets, such as the Suggest Box, ListGrid and TreeGrid.

The data usually comes from a database, a Web Service or another server-side data source. In 4.2 we provide a server-side Data Module that transforms data from any server-side data source to the data format that is required by the Client Framework. You can read more about this in the ‘What’s new for Java’ article.

Adobe AIR Support

With Adobe AIR 1.0 you can turn your Backbase Enterprise Ajax 4.2 application into a desktop application, including local data storage, desktop drag-and-drop, integration with the system tray and more. Very shortly we'll publish a sample application on the Backbase Developer Network (BDN). This is an RSS reader that stores the RSS feeds locally, so you can also read them when offline (see screenshot below).

Redesigned Chameleon Skin

The Backbase Widgets were already looking pretty slick, but they now look even better. The Chameleon Skin has been enhanced to make sure that Widgets fit well together.

The new skin looks very polished, and the new 'Stretch' widget does away with the unnecessary scroll bar

New and Improved Widgets

Backbase 4.2 includes several new and improved widgets, among which:

Stretch

The Stretch Widget solves a well known issue in Web UI development: correct handling of browser resizing and font resizing. The Stretch Widgets fills up the space between 2 other widgets. If you resize the browser window or change the font size, it will dynamically expand or shrink. A Panelset is similar but doesn’t support font resizing correctly. So the Stretch Widget makes it easier to deliver scalable UIs.

See Sample Layout 3 for the Stretch Widget in action.

Groupbox

Groupbox is a widget known from desktop programming environments, such as Microsoft and QT. It is a grouping element, essentially a box with a label. This allows you to better organize your user interface definition.

Icon support

Often you want to use small icons in your UI, such as a ‘save’ icon in the file menu. Backbase 4.2 now provides hooks to quickly add those icons: you just specify a CSS background image. This can be used for the following Widgets: Window, Accordion, Navbox, Groupbox and Menu.

Icons can be defined with a simple icon attribute: the icon location is specified in the CSS file

Rich Text Editor (Beta*)

With 4.2 we're shipping a beta Rich Text Editor, which provides WYSIWYG text editing. The buttons for the editor are configurable. Underneath it's a normal text area, so it can be included in HTML forms. Below is a screenshot of the editor:

New: Sample Application Layouts

The new sample application layouts illustrate how Backbase widgets can be combined to achieve a variety of practical application layouts. Select a template that most closely matches your requirements, and use the easy-to-follow code to have the basic layout of your application up-and-running in minutes.

Just two of the several sample layouts that are included in 4.2

Improved Documentation

For the 4.2.0 Version of the Backbase Client Framework, the API Reference has been restructured. It has become easier to find information and its organization has become more clear. In an ongoing effort, new examples have been added and old ones have been improved.

The Widget Development Guide has been almost completely rewritten. There are now several leading examples that show you many facets of the TDL markup language in an incremental fashion. The source code of the examples has been provided in the product package.

Performance Enhancements

Ajax performance depends on three main phases:

• Load phase: loading all files from the web server (HTML, CSS, JavaScript)
• Build phase: processing of these files by the Ajax engine on initial load
• Runtime phase: runtime execution, such as event handling

With 4.2 we’ve identified and removed performance bottlenecks in all three areas. To speed up the load phase, we’ve done three things:

• The Core Engine loads fewer files, reducing delays caused by latency
• Production version: when deploying your application, you can use the production version of the Client Framework. The production version is minimized, and does not include any development tools: therefore it loads faster.
• Binding optimization: you can group multiple binding files into one file, so fewer files have to be loaded from the server

For the build phase we’ve implemented internal optimizations in the Client engine, resulting in a performance boost of approximately 15%.

To make the runtime faster, we’ve optimized the engine. Additionally, we recommend using the production version of the Client Framework, which is about 20% faster than the development version.

In our development lab we use fully automated performance tests that not only test performance differences between two builds, but also performance on the various browsers. When IE8 beta 1 was released, we published some test results. See the graph below (shorter bars are better):

Other Improvements

As with every new version, we always include many small improvements that were requested by the Backbase Community. Just a couple of highlights from this list:

• Improved drag and drop implementation: the mouse pointer location is now more precise, so dragging is smoother
• XML Schema implementation moved to the core engine for better performance
• Added the events DOMFocusIn and DOMFocusOut to complete our DOM Level 3 Event support
• Added NSResolver to properly handle namespace prefixes, especially across multiple documents or when the same prefix is used for multiple namespaces
• Improved reflow implementation, so that font size changes correctly trigger the reflow of the user interface
• Support for Safari 3.1
• Thoroughly tested on Firefox 3 beta, and initial testing on Internet Explorer 8 beta

* Beta Widgets: functionality and API may change in future releases