Lanikai Beta 1, available now for download, is built on top of the Gecko 1.9.2 platform. While this milestone is considered to be stable, it is intended for developers and members of our testing community to use for evaluation and feedback. Users of this latest alpha version of Thunderbird should not expect all of their add-ons to work properly with this milestone.

The main goals of this release is to find out about possible problems caused by the changes in the underlying platform. Notable changes include:

• Several fixes to improve upgrading from Thunderbird 2.
• Several fixes for auto complete, tabs, and activity manager.
• Several design improvements and corrections to the interface.
• Stability and memory improvements.

For a more detailed list of bug fixes, see the the full bug list.

The Rumbling Edge has a more detailed list of notable bug fixes.

Downloading

Please read the release notes before downloading for more information about this release including known issues.

Testers can download Lanikai Beta 1 for Windows, Mac OS X, and Linux in English. Community chat about Lanikai can be followed at GetSatisfaction and on irc.mozilla.org in #thunderbird.

Sinasi is Not a SproutCore IDE:

If you love emacs and you love SproutCore, Sinasi will make your data complete.

The March edition of the OpenLaszlo <view> is available here:

http://www.openlaszlo.org/misc/OpenLaszloView030910.pdf

The new Get Tree from Page example demonstrates how the Uize.Node.Tree.getTreeFromPage static method of the Uize.Node.Tree module can be used to build a tree data object respresenting the structure of the document, by analyzing the occurrence of different CSS classes for section headings at different depths of the document (in this case, the CSS classes level1Header, level2Header, and level3Header). A tree data object like this can be supplied to a tree menu widget, or can otherwise be used to build UI for navigating to different sections of the document (a contents tree, for example).

The new Get Tree from List example demonstrates how the Uize.Node.Tree.getTreeFromList static method of the Uize.Node.Tree module can be used to build a tree data object by analyzing the structure of a nested list defined by an HTML ul tag. A tree data object like this can be supplied to a tree menu widget, or can otherwise be used to build UI for navigating to different sections of the document (a contents tree, for example).

The new Uize.Node.Tree module provides convenience methods for generating a tree data object by analyzing HTML on a page. A tree data object is an array, where each element of the array is a Tree Item. Because a Tree Item may itself contain a child Tree Data Object, specified by its items property, a Tree Data Object can be used to represent an arbitrarily complex, hierarchical structure for information. A Tree Data Object can be used in any number of ways, but is commonly used for building tree-based user interface elements such as contents lists, structured dropdown menus, etc. A number of widget class support data in the Tree Data Object format, such as the Uize.Widget.Tree.List, Uize.Widget.Tree.Menu, and Uize.Widget.Tree.Select classes. Outside of widgets, tree data objects can be used to drive the generation of HTML, in build scripts or Web applications, using JavaScript Templates.

A number of instance and static methods of the Uize.Widget.Tree module have been deprecated and migrated into the new Uize.Node.Tree module. The getTreeFromList and getTreeFromPage instance methods, along with the Uize.Widget.Tree.getTreeFromList and Uize.Widget.Tree.getTreeFromPage static methods, have been deprecated and migrated into the Uize.Node.Tree module as Uize.Node.Tree.getTreeFromList and Uize.Node.Tree.getTreeFromPage. For backwards compatibility, the deprecated instance and static methods of the Uize.Widget.Tree class are all still supported, and will be supported for some time. All existing code using the deprecated methods should continue to work as normal. It would be wise to progressively migrate code over to using the static methods in the new Uize.Node.Tree module. In order to achieve backwards compatibility, the Uize.Widget.Tree base class now requires the new Uize.Node.Tree module. Other than that, the static methods in the new Uize.Node.Tree module have the same signature and behavior as the deprecated methods of the Uize.Node.Tree module.

The Uize.Population module has been migrated to under the Uize.Widget namespace as Uize.Widget.Population. For the most part, the interface is entirely the same and compatible with the old interface, with some very minor differences. As a widget class now, instances of the Uize.Widget.Population class must be wired (by calling the wireUi instance method) before changing the value of the items set-get property will result in an update of the contents of the instance's DOM node. Also, as a true widget class, instances of the Uize.Widget.Population class can be added as child widgets of other widget instances. Finally, the DOM node into which generated HTML is injeted can now be specified with either of the idPrefix, node, or container set-get properties. This change, which is not backwards compatible, has the benefit of further cleaning up the Uize root namespace. The two examples that were previously using the now defunct Uize.Population class, Populating Photo Details and Structured Record Population, have been updated to use the new Uize.Widget.Population class. If you were previously using the Uize.Population class, then you can use these two example pages as a reference when updating your own code.

The Uize.Url module has been improved with the introduction of the Uize.Url.from static method (actually, it's existed in the code for a while, but has never been officially documented or fully tested). The Uize.Url.from static method returns an object, containing properties for the various logical segments of the specified URL string. This method provides a convenient way to get at very precise portions of a URL string, such as the file name without the extension, the file type without the "." (period) character, the query params string without the "?" (question mark) character, the anchor without the "#" (pound / hash) character, etc. The Uize.Url.from method is comprehensively documented and fully tested. Additionally, all static methods of the Uize.Url module are now fully unit tested by the module Uize.Test.Uize.Url.

The new Uize.String.Lines module provides methods for working with multi-line strings, supporting indenting, changing linebreaks, modifying lines, etc. The Uize.String.Lines module lets you easily... 1) iterate across lines using the Uize.String.Lines.forEach method, 2) modify the contents of lines using the Uize.String.Lines.modify method, 3) filter lines using the Uize.String.Lines.retainMatching, Uize.String.Lines.removeMatching, and Uize.String.Lines.removeBlanks methods, 4) trim whitespace on all lines using the Uize.String.Lines.trim, Uize.String.Lines.trimLeft, and Uize.String.Lines.trimRight methods, 5) analyze and modify indentation on all lines using the Uize.String.Lines.getIndentRange, Uize.String.Lines.indent, Uize.String.Lines.switchIndentType, and Uize.String.Lines.normalizeIndent methods, 6) analyze and modify linebreak type using the Uize.String.Lines.getLinebreakType and Uize.String.Lines.switchLinebreakType methods, and 7) split a multi-line string into a lines array using the Uize.String.Lines.split method.

As an aid to developers of the UIZE JavaScript Framework, the new SOTU (State of the UIZE) page provides an overview of the state of all the modules that make up the framework. Developers of UIZE modules can use this document as a guide on where work is needed. The table below provides information on various aspects of UIZE modules: things such as estimated code completeness, estimated documentation completeness, unit test completeness, scrunched file size, etc. The table's columns are sortable, so if you want to sort the modules by documentation completeness, you can do so clicking on the "DOC" heading. Or, if you want to see all modules of a certain type, sort by the "MODULE TYPE" column and then scroll to the module type you're interested in - they'll all be clumped together. The "IMPORT." column is a high level assessment of the importance of modules in the grand scheme of things, so this can also inform where effort is invested in writing documentation and tests.

The new Zooming Collection Item with Image Switching examples demonstrates how the Uize.Widget.CollectionItem.Zooming widget class handles dynamically switching the image that it displays. In this example, the Uize.Widget.CollectionItem.Zooming widget class is being used to add a JavaScript animation zoom in effect to an image. In contrast to the Zooming Collection Items example, which simply demonstrates this widget applied across multiple images in a grid, this example demonstrates how the value of a single instance's previewUrl set-get property can be changed dynamically, and how the zoom and pan behavior still works as expected after the image URL has been updated.

The new Uize.String.Builder module implements an object to facilitate the building of very large strings, in a way that minimizes performance costs. Building strings using a traditional incremental concatenation approach using the += (incrementing assignment) operator can be slow in certain JavaScript interpreters when very large strings are being built. One way around this performance issue is to use an array to accumulate all the segments of a large string, and then concatenate all the elements of that array at the end of the string building process using the Array object's join instance method. The Uize.String.Builder object wraps this pattern up neatly into an object that also provides the benefit of String object parity that wouldn't otherwise be available in a manual array building process. In doing so, the Uize.String.Builder object can provide a substantial performance benefit in certain applications. This new module is comprehensively documented and unit tested.

The Uize.Scruncher JavaScript scruncher module has been significantly optimized in order to dramatically speed up the scruncher build script, along with all other processes utilizing this module. The scruncher's algorithm for parsing and compacting JavaScript code has been optimized for speed using a variety of different optimization strategies. The end result is that scrunching a JavaScript file is now many times faster. As an illustration of this improvement, scrunching all the JavaScript modules in the uize.com Web site project (over 180 of them) previously took about 45 seconds on one machine. The exact same process now takes about 11 seconds on that same machine! The benefits of this performance optimization will be keenly felt in larger Web site projects that have lots of additional proprietary JavaScript modules. And, because the build script for building reference documentation from comments inside JavaScript modules also utilizes the Uize.Scruncher module for extracting SimpleDoc comment, the documentation build script will also run much faster.

The Uize.Data.indexIn and Uize.Data.isIn static methods of the Uize.Data module, that were both deprecated way back in December of 2008, have finally been killed. The identical functionality provided by the old methods is available in the Uize.indexIn and Uize.isIn static methods of the Uize base class.

The new Uize.pairUp static method, implemented in the Uize base class, returns an object that is the specified key and value, paired up together in the same object. For example, the statement Uize.pairUp ('foo','bar') would produce the object {foo:'bar'}. The Uize.pairUp method is useful when an object needs to be created from a key/value pair, where the key name is either dynamically generated in an expression or is supplied via a parameter. Using the Uize.pairUp method, you can collapse what would normally be three statements into just one.

A section has been added to the JavaScript Modules explainer discussing ways to use JavaScript modules to package data in a special type of module called a data module. Data modules are modules that only define data structures, and are a convenient means of representing data that is to be used by JavaScript code. As modules, data modules can be required by other types of modules, and can therefore be loaded by the module loader mechanism, which can obviate the need to load data through XMLHttpRequest requests, providing one way of delivering data for cross-site scripting (XSS) while also allowing data to be loaded from local files by Web pages that are run locally. As modules, data modules can require other data modules, allowing more complex data structures to be built up using shared subsets of data that are defined in other data modules (see Composite Data Module). Furthermore, data modules can use other modules for programmatic generation of data, or for the expanding of compressed data. Data modules can be generated dynamically by server side code (see Dynamically Generated Data Module), allowing the module loader mechanism to be used as an alternative to traditional approaches to XSS (Cross-Site Scripting) data requests. The newly added documentation discusses various aspects of data modules, including one suggested implementation approach, a few other possible implementation approaches, the benefits of deferred construction of data objects, dynamically generated data modules, and composite data modules. To read this new documentation in full, consult the JavaScript Modules explainer and browse to the Data Module subsection under the section Types of Modules.

The new Drag-to-move example demonstrates how to wire up a bunch of image thumbnails so they can be dragged around a workspace. In this example, the Uize.Widget.Drag.Move widget class is being used to wire up a bunch of image thumbnails so that they can be dragged around a "workspace". This is a very basic example of drag-and-drop - there are no drop targets to speak of. Instances of the Uize.Widget.Drag.Move class are wired up for all the thumbnails in a single statement, thanks to the Uize.Widget.Drag.Move.spawn static method. The Uize.Widget.Drag.Move class doesn't deal with managing z-index - just coordinates. It does, however, support coordinates specified in units of px (pixels) as well as % (percent).

Basic reference documentation has been added for various JavaScript template modules under the Uize.Templates namespace. This update adds documentation for the following JavaScript template modules: Uize.Templates.Calculator, Uize.Templates.Calendar, Uize.Templates.Collection, Uize.Templates.CollectionItem, Uize.Templates.ColorInfo, Uize.Templates.HashTable, Uize.Templates.JstModule, and Uize.Templates.List.

The new Color Gradient Tool provides a UI for visualizing and experimenting with color gradients. By applying different curve functions to different color components, color gradients can range from basic color transitions to sophisticated spectral patterns. Using this tool, you can select a color gradient from a "PRESETS" tab. Upon selecting a color gradient preset, the color gradient will be previewed in a display area. The parameters for a color gradient can be tweaked inside a "PARAMS" tab, and those changes can then be previewed. Moving the mouse over the gradient preview will display a tooltip that contains information about the color being moused over, and clicking will provide the hex value of that color in a prompt dialog so it can be copied to the clipboard. So, this tool also provides a novel approach to a color picker UI, since it lets you choose a color from unique color spreads.