Greetings, qooxdooers, for another weekly wrap-up of the state of affairs in qooxdoo!

General

qooxdoo 0.8-alpha2 has been released just a week ago, thanks for all of your feedback. In the following days, major parts of the Sourceforge.net service platform (which also hosts qooxdoo) were moved both physically (from California to Illinois), as well as concerning software versions. We don't know about you, but we felt major impacts of this migration, even after its official completion. Among other things the statistics features of Sourceforge will remain dormant until next month, so we don't even have download figures for our latest release .

But "after release is before release", and we are already in full gear for qooxdoo 0.8-beta1, planning its scope and dispatching tasks. More details will be available soon at this space.

With keen interest we followed the recent release of Jython 2.5a1, a Python implementation in Java. As our tool chain is increasingly built on Python this is an interesting extension of available runtime environments for this code, and will most likely be warmly welcomed by developers at home in a pure Java environment. Initial tests with our generator done by Fabian were indeed promising, and we are looking forward to full support of our build tools by Jython.

Applications

The initial phase of basing our build chain on the new generator is drawing to an end. Nearly all targets available under the make-based system are now available with the new generator as well, the notable exceptions being 'make test' and 'make buildtool' which will be supplied later. Invocations of the 'make' command are now just a wafer-thin wrapper around the generator invocations which becomes apparent with some of our standard applications like the Feedreader. The Apiviewer is self-hosting again, i.e. you can generate the API documentation of the Apiviewer itself.

The documentation of generator configuration got much love from Thomas, and is now split into a main page, a page with in-depth articles about important concepts, and a reference listing of the configuration keys.

And finally, the Showcase application which showed its age has been removed, at least for the time being until it can be re-surrected with new shine and glory .

Framework

A first basic implementation of a low level text selection API has been added. Currently this API allows to get the current selection as string and the current selection length as well as to set a selection on elements, text nodes and of course form elements (input and textarea). This API is available for all four major browsers Gecko, IE, Webkit and Opera.

Without further a-do, here is what else happened in the framework:

• Most bugs reported for alpha2 were fixed - thanks to all the submitters.
  • A listener was added for draggesture events, to block gecko's native drag and drop when resizing/dragging qooxdoo widgets around.
  • Window resizes now keep the correct cursor.
  • Support was added to minimize/maximize windows.
  • Flickering on initial click on a widget has been removed.
• Support for line height property in fonts has been added.
• More Window refactoring:
  • support for modal windows
  • extracted MMovable mixin
  • refactored MResizeable
  • added possibility to block interaction with the window contents; needed for advanced modality support
• Port of Menu has been started
• Port of the Table has been started
• TabView has been polished
• Work has been done on a modern TabView appearance

Community

This week another qooxdoo real-life example surfaced. Zed Builds & Bugs Management is an application targeted at software development teams and combines the following components:

1. Automated Software Build Management
2. Task, Bug, Feature, Assignment, etc. Management
3. Discussion Forums for team dialogs
4. Wiki for documentation, team group design, document storage, personal pages, etc.
5. General server administration

The power of the application is in it’s pure web (qooxdoo!) interface, and the database which is shared among all facets of the application. Meaning your Wiki pages can query the task database, and your automated builds can update tasks as well.

If you created a qooxdoo application (or any software that leverages qooxdoo), please let people know about it. It is an excellent way to give back to this open source project. Just go to the real-life examples and add a section for your app, maybe including a screenshot, and add a link to an online demo if available. Thanks!

Keeping up with our tradition of Friday's weekly reports, here is another, albeit very brief one.

This week was really a finish towards the 0.8-alpha2 release which we pushed out of the door this morning. Hope you're all hanging out with it . Most of the activities went straight to the release notes, so please check there for latest changes (although the release notes cover everything that happened since alpha1, so you might have to wade a bit through the details).

One other thing worth mentioning was a lively thread on the mailing list, about code assist files for IDEs (Eclipse, Aptana, ....) entitled "jseclipse". Discussion gravitated around generating code assist files from API documentation output from the generator. People interested in that should also look at the - unfortunatley somewhat outdated - wiki page about qooxdoo and Aptana. There were some interesting ideas floating around, so maybe we can build up on that. If there is code starting to accumulate around this topic we could set up a qooxdoo-contrib project.

That's it for this week - we're going to post-release-climactic chill . Be in touch next time.

German Java Forum 2008

Andreas and Fabian joined the Java Forum 2008 (german web site) on Thursday in Stuttgart, Germany. There will be a dedicated post about this one, but among various interesting presentations there seemed to have been a surprising amount of interest in qooxdoo. Stay tuned...

Generator

The Generator basically saw the addition of some missing targets from the Makefile world, like 'clean', 'pretty' or 'lint'. That means the new Generator is nearing feature completeness as far as the driving of project-level targets/jobs is concerned. Also, the module structure has been improved.

Dynamic switching of locales and themes

A major issue of concern during the last few weeks was the cost and benefit of supporting locale and theme switching at runtime in the next version of our framework. To that end, Fabian started a general poll on the mailing list to find out how important these features were for our users. In his summary of the ensuing discussion, he expressed surprise about the amount of support in favour of locale switching. Fortunately, there was also a solution found that promises both the availability of locale runtime switching but at a reasonable cost on the implementation side.

The envisioned solution will implement locales as being static during runtime as the default, which will result in some memory/performance gains. But it will also offer a dedicated setting to turn dynamic switching on for an application, and then the runtime costs will be about the same as they are in the current version. So this feature will continue to be available for those who wish to use it. On the implementation side, the relevant point was to bypass the (costly) LocalizedString class and use built-in Javascript strings to handle necessary meta information.

Runtime switching for themes is still an open topic. There were fewer postings speaking in favour of it, but still some interesting technical suggestions how to continue it in a more feasible way. This will be sorted out in the near future.

Framework

Here are a few more ramblings about recent changes in the qooxdoo framework.

• The 'Modern' theme is making advances, and we expect to have a working version during this week.
• A major refactoring of the focus system now leads to unique support for complex cascaded widgets like the Spinner or the ComboBox. The outer widgets always receives the focus event etc., and still the caret is visible when jumping from field to field when using the keyboard. Widgets also now have the possibility to differentiate between tab focus and normal focus.
• All qooxdoo widgets use the new subcontrol support now. This means that features built on this like the new appearance theme handling are now much more widely used. More details on this feature and the changes to the appearance themes needed will follow in the coming weeks.
• Support for aliases has been added to reduce the size of themes. Aliases also make the new sub control support a lot more usable. It greatly reduces the overhead introduced with the sub control handling in the last week.
• State inheritance to sub controls is now supported. This means that every child control like e.g. the up-button of the Spinner can be informed about specific state changes, such as "focused". This is especially useful or even required for better looking themes. You can see the new feature live in the improved Spinner and ComboBox widgets.
• Greatly improved performance of the appearance system through an improved caching algorithm. Instead of dynamically sorting an array and concat'ing it to a unique identifier the new implementation is based on a simple arithmetic loop. There were some other improvements as well. Especially the new alias support, as mentioned above, results into a few performance improvements as well.

Some minor improvements include:

• Fixed PageUp/PageDown support in all ScrollArea based widgets like the List.
• More API docs were fixed or extended. Especially in qx.html.* and qx.ui.core.*
• The TabView widget was improved to make better use of the SlideBar widget.
• The GroupBox widget was fixed and now correctly handles all legend types e.g. Atom, RadioButton or CheckBox.
• Added some new methods to the lower level classes in qx.html.*, to give a better API for focus related features of the widget system.
• Fixed appearance queueing for dynamic widgets like the Atom. Sometimes the states were not correctly displayed after initial rendering.
• Improved Splitter demo. The code was structured into separate methods.

That's it from this week's qooxdoo - enjoy your time!

Portal - A Low-level DOM Demo

With Portal a new application has entered the qooxdoo trunk. This small demo shows some cool features of the new low-level layer, which will be a subset of the upcoming qooxdoo 0.8 release. This layer does not use any of the high-level qooxdoo widgets. Instead, it is a lightweight, DOM-oriented solution that provides an alternative to other popular libraries like Prototype or jQuery. Of course, it is fully cross-browser and allows for very sophisticated coding by offering all the well-known OO features of qooxdoo. A comprehensive API documentation - even for such a low-level app - can easily be generated. Be sure to check it out!

Eclipse Ganymed

Probably you have already heard about the release of Eclipse 3.4 (called "Ganymed"), which was made available about two days ago. They stick to an annual release cycle, so the new version includes a lot of fixes and improvements. If you are an Eclipse guy, you probably have the IDE (which is only one but the most prominent part of the entire Eclipse ecosystem) installed and running already. If not, this is a good opportunity to give the Eclipse IDE a try. While it may not be perfect (well, what editor or IDE is?), it is an excellent solution. Best of it, it's open source! Of course, we had to celebrate the new Ganymed release at one of the DemoCamp events.

Generator

A major part of this past week went into carving out the Config and Job classes that are responsible for providing the information from the config files to the rest of the Generator. They handle all the including of configs and expanding of jobs, returning a fully expanded job that has all the information and is ready to be run. The code is now clearer, better organized and reflects much better the "theory" behind it. I really started loving it.

On the feature level, these are the news:

• Name space-less includes
  As mentioned in a previous post, jobs from external configs are added to the local job list (they are "lifted"). Previously, these imported jobs were renamed to include a prefix that acted as some kind of name space, and thus could prevent name clashes. This has been disabled by default, so external jobs will now be added to the list of runnable jobs with their original names. This puts the burden of avoiding name clashes on the importing config, but now you can run e.g. a 'source' job without even defining one.
  On the other hand, you can still define optional name spaces for the job names from those imports. To support this, the syntax for the top-level include key has been changed; it is now an array holding a map for each imported external config. The mandatory entry in those maps is a 'path' key that points to the file location. If you wish to import the jobs namespaced, add the optional 'as' key in the respective map. The format for referencing those jobs slightly shifted to use '::' as a name space separator (rather than '/'), so if you used

    "include" : [ { "path" : "../my/other/config.json", "as" : "otherConfig" }  ]

  you could refer to a job from that config e.g. in an 'extend' section like this

  "extend" : [ "otherConfig::<jobname>" ]

  and external jobs will also be listed in this form on the command line with '?' as the jobs argument.

• 'export' lists
  Configs can now list the jobs they want to get exported when another config includes it. This is just a selection from the entire list of this config's job keys, and helps to limit name space pollution in the importing config. The syntax is a straight-forward top-level entry like this:

  "export" : [ "jobA", "jobB", "jobC" ]

• Top-level macros
  You can now add a 'let' section on the top-level. Macros defined therein will be added to every job automatically and without explicit reference, so be aware of side effects. If a job already defines a 'let' map, the global map will be merged into the local in the usual way, only adding new keys and their values. This is done before any extend is resolved, so keys from the global let take precedence over all jobs from the extend section. - The rational behind it is that most standard configs can be reduced to just including the 'application.json' default config, and adding some macros. The experimental 'defaults' job that had similar qualities is gone.

The full documentation for all these config settings is available here.

If you look at the current config.json files of our standard applications (Apiviewer, Feedreader, etc.) they are on various levels of making use of configuration features. Some rely on the settings from the central application.json, others make their settings explicit, doing it more "by hand". Expect to see more features moving into these config files while the config file feature set stabilizes.

Widgets

Subcontrol support

Subwidgeting and child widget handling was a major theme this week. Subcontrol support was added to a lot more widgets thanks to Jonathan's and Sebastian's work. This new widget managment is used for lazy creation and automatic disposal of widgets, but also for the new appearance theme features. Every subcontrol is seen as a child in the appearance as well. The previously flat structure flag keys became somewhat structured resembling XPath expressions, e.g. "spinner-up-button" became "spinner/upbutton". Here are some more facts:

• These widgets now use child controls:
  SplitPane, ComboBox, SelectBox, Spinner, Toolbar, TabView
• These widgets use remote children handling now:
  ComboBox, SelectBox, Toolbar
• ComboBox and SelectBox have gotten a nice "Modern" theme.
• All appearance names have been consolidated (e.g. it is now "textfield" instead of "text-field")

Spinner

The Spinner is completely themable with all internal children by changing the (public) appearance property. All internal widgets get updated automatically. The minimum/maximum handling of the Spinner was improved. The new version does not accept a value anymore which is out of the currently configured range. The old version did some implicit normalization which is not regarded as a good idea anymore.

ScrollArea

Some remaining issues in the ScrollArea were fixed. The scroll-into-view feature is now available on every widget and is automatically scheduled using the queue managment when the widget or the child to scroll is not rendered at the moment. Gecko and Safari lost the current scroll position when a DOM node gets invisible or temporarly removed. This is an issue for us, especially in the new Selectbox and Combobox widgets because they should re-open the popup in the state they were closed. The scroll area now takes care of these issues and recovers the last known state on every open of the popup.

Miscellaneous

The Element event handler was fixed. After some rework of the event system some weeks ago this handler got a few issues. Events like "scroll" or "load" etc. should now work again.

The Selectbox and Combobox widgets have gotten another bunch of love. They are now regarded as nearly feature complete and appear to be quite solid already.

The Splitpane widget has got a lot of fixes to improve the rendering in some edge cases. The issue where the splitter was moved some pixels away from the cursor on the mouse up event was fixed as well. There are no known rendering issues anymore in the splitpane. Please try it yourself.

Global cursor support was re-introduced in the trunk. As this was a performance issue in IE all the time and never worked 100% OK, the feature was removed in IE. In all other browsers the feature is quite cool, especially for scenarios like resizing or drag&drop where the original target is left during a mouse move sequence. You can see the feature yourself in the Splitpane demo.

Some minor issues with the event handling where fixed. The last weeks version had issues to remove captured listeners. This is quite critical in some areas and good to know that it should now work correctly.

That's for this week's report - have a nice weekend!

Welcome to a new weekly status report.

Siarhei visiting

This week we had Siarhei visiting the qooxdoo framework team at 1&1 in Karlsruhe. Before, we knew each another just from the mailing list and individual emails, so it was a great experience to meet in person. We had a lot of fun hanging out together, watching games of the Euro 2008 Soccer Championship. Of course, we also talked a lot about qooxdoo, QxTransformer and a lot of interesting technical stuff, be it related to qooxdoo or more general. Siarhei (pronounced like "Sergey" as we learned) is from Minsk/Belarus and was on a business trip at a local customer. If you also happen to be in Germany and possibly close to Karlsruhe, let us know, we'd be happy to invite you over to meet the team.

Generator

Generation of different files according to chosen variants were added, and a new section on packages has been added to the config manual. The generator.py command line was simplified through making the -c switch optional and defaulting to config.json, and removing the -j switch and making the job list into an argument. Please adapt your build invocations.

String Optimizer

The string optimizer in 0.8 now creates a closure around each class and defines scoped variables. In earlier version an global array (for all classes) was used which helps to reduce the cost of strings in IE dramatically, but still means that you have an additional lookup to an array index. The inspiration came from GWT. They seem to optimize strings in the same way. And from now on qooxdoo can do the same for every qooxdoo 0.8 application.

Fun with IE stack size exceeded

We ran into an issue this week while working with list widgets where IE would bomb with a stack-size-exceeded message. Since it is not trivial to find the code that might cause this stack overflow, we used qooxdoo's AOP features to track down the issue. To that end a Tracer class was defined that would record stack depth and store the highest reached stack depth and the corresponding stack. (For your own aspect classes you can find a template here).

Finally it was related to some redirection of the focus in the original focus event. The implementation for IE used a native method to make elements active, this was one cause of the issue. Finally I also cleaned up a lot of the existing code. It is somewhat complex stuff. The focus handling has nearly completely different implementation for each supported browser. It looks quite good now. The support for Opera and Safari was improved as well and seems to be quite solid now as well. You might want to have a look yourself into the various examples.

Scrolling TabView

This is somewhat like a quite old issue. If a TabView in 0.8 has too many tabs to show them together you automatically get two scroll buttons to slide the tabs to the desired side. This is never a good choice from the usability point of view, but still a good default behavior for any toolkit.

Legacy_0_7_x

Fixing memory leaks in various widgets - thanks for the submissions.

C U next week.

Another week towards the qooxdoo 0.8 release. We're making constant progress so you should get started to become excited (in case you aren't yet).

qooxdoo 0.8

SplitPane

Porting the SplitPane widget is almost done. The new version is much leaner and nicer using only three classes instead of six since, much of the styling can be done using the appearance system and decorators. Furthermore, the new API is much easier to learn: Only two accessor methods are used to access the widgets inside the SplitPane instead of having eight different methods depending on the SplitPane's orientation. Adding widgets is more convenient, too: a SplitPane is filled from top to bottom or left to right, respectively.

The size-handling was improved as well. Instead of passing the sizes (or flex values) to the constructor, static sizes are set on the widget itself before insertion; flex values on the other hand are layout properties which are set when adding a widget to the SplitPane.

See a first SplitPane example. Please note, it is still work in progress so some features (such as live resizing) may not be working properly just yet.

Widget Core

A possibility for compound widgets was added to redirect the properties "padding", "font" and "textColor" to an internal sub widget. For example setting the padding property on a window instance will now redirect to the padding of the window pane instead and thus no longer break the layout.

Window

Talking of windows, they can now also be centered easily. Another demo has been added to demonstrate how a custom web browser could be implemented in a qooxdoo window (Oooh, don't you love the 0.8 theming...).

Documentation

First steps of re-organizing the wiki to account for the qooxdoo 0.8 documentation have been made. Also a first draft of a fundamental GUI overview article has been created. This article will get some more love and polishing within the next few days. In case you haven't seen it, also check out the blog post about the layered architecture of the upcoming GUI toolkit which. As its covers "From DOM to Widgets", shouldn't we have called that "From Dusk till Dawn" instead?

Runtime switching

In 0.7 there are two features that allow for switching both locale and theme at runtime. While these are nice features per se, they don't come without a cost in terms of application performance and code complexity. As qooxdoo further matures we think it's time to drop such features that may not be too relevant in real-life scenarios. In order to get some feedback from the community we started a thread on the mailing list. If you have an opinion or experience, please share them with us.

Generator

The tool area of qooxdoo saw some SVN re-org in the 'ecmascript' module, to prepare for further modularization of the compiler.

In the realm of configuration, "job lifting" has been implemented whereby imported jobs are added to the jobs map of the importing config, rather than under a common name space entry. That means that imported jobs can now be listed with '-j ?' or invoked with '-j <jobname>' from the command line of the generator. Still their names are prefixed with a namespace-like string on import, to avoid name clashes. But we plan to change this so jobs will be imported under their original name, putting the demand of resolving name conflicts unto the importing config. But this way we can offer a 'source' job on the top-level which is actually imported. Together with global definitions which are recognized without being explicitly referenced (currently, there is an experimental "defaults" job), this all adds to the ultimate goal to have config files on the application level that have only to specify a minimal amount of information for all the standard jobs 'source', 'build', 'api', ... to work, as long as they have no special requirements. In a future step, the list of jobs to be imported can be specified by the exporting config, to limit the number of symbols (think: jobs) that are added to the importing config's name space.

Abobe on AIR Tour

Adobe did a great job offering a one day conference on Adobe AIR with technical sessions, showcases and discussion. It was part of their on AIR Tour Europe 2008. In order to make this event even more attractive they made sure to "provide the beer, coffee, food, XBoxes, schwag, knowledge, venue and bits". Of course, we didn't want to miss out and went to Munich to socialize with some of the Adobe developer folk, also meeting again some people we knew from previous conferences. As expected it was a fine event and we particularly enjoyed talking to Kevin Hoyt (Adobe) and Wolfram Kriesing (Dojo).

As qooxdoo has been one of the first adopters of Adobe AIR (dating back to July 2007!), it somewhat reminded us to re-introduce AIR support into the framework and also to extend it to include features of the latest AIR versions. It may not be all too soon due to our focus on qooxdoo 0.8, but you can bet on some smart AIR support in the future.

Ultimate Party

As the perfect end of the working week and start into the weekend we now leave for the ultimate 1&1 summer-time party. There should be roughly 2.500 fellow coworkers of 1&1 having a great time this evening. Wanna join a great company? Check out their international job offers as well as the qooxdoo-specific job offers. Hurry up, next big party is right before Xmas.

Cheers and have a nice weekend!

After successfully participating in conferences (webinale, Dynamic Languages World), we are getting used to our "regular" development work again...

Community

Slides

In case you haven't seen the presentations yet, check out the slides that have been uploaded to the SlideShare service, using "qooxdoo" as a tag.

Bugzilla

Continuing with development of qooxdoo 0.8 we took the opportunity for some overdue spring-cleaning of our issue tracking system. It's work in progress, but we have already started to use bugzilla more intensively in order to make the development process more effective and also more transparent. Todo items have been moved over to bugzilla. Within bugzilla, 'application' and 'tool', which were previously in the 'product' category, are now subsumed under the 'framework' product, and existing bugs have been moved accordingly. This helps e.g. to have consistent version and target attributes for all framework related stuff. Once the dust has settled there will certainly be more info on the blog.

Real-life examples

If you are feeling happy having created a cool qooxdoo application, it would be great to share this info with the community. Please add your app to the real-life examples. Besides a short description, you might want to provide links to the online version of your app, or screenshots if it is an intranet and/or non-public solution.

Framework

Events

Searching for the correct qooxdoo event handler has been heavily optimized. "addListener" calls are much faster now (Bug #895). Methods firing an event like "fireEvent" or "dispatchEvent" now return false if the event was canceled using "preventDefault". "addChild" and "removeChild" events are now fired on "qx.ui.container.Composite" widgets each time a sub-widget is added or removed.

Window widget

Lots of events were implemented (close, maximize, minimize, restore, beforeClose, beforeMaximize, beforeMinimize, beforeRestore). The actions which correspond to these events can be canceled by calling "preventDefault" on the event object. The new sub-widget system is being used for Window, the status bar is created lazily. Also, the decoration has been improved.

Other widget stuff

• There is a new SelectBox widget. The SelectBox is a non editable version of the ComboBox.
• The SplitPane is in the process of being ported to the 0.8 widget system, with a completely new layouter for this widget. The widget itself is still missing, but the underlying layout looks quite good so far.
• Completed API documentation of ScrollArea. Cleaned up and improved more implementation blocks. Support for "scrollIntoView" was refactored to use newly available methods.
• Support for scrolling of "not-yet-rendered" widgets. This also includes "scrollIntoView" support. With the new version it is possible to select list items during the main() method. Items selected this way are automatically scrolled into the viewport.
• Initial focus support is back in SVN. It is now possible to focus widgets during the main() method and make them focused on initial display of the application.
• Introduced support for shrinking to Atom (basis of Buttons, Tabs, ...). The Atom now shows an ellipsis symbol when the label is not completely visible.
• The selection managed by a selection manager now gets notified each time a selectable item is added or removed from the managed widget. Improved selection system to fix issues when the selection is changed programmatically. Previously, the lead or anchor items were not updated correctly in some cases.

Miscellaneous

• The user data support has been moved into qx.core.Object. Now it is possible to add any type of runtime data to any instance of qx.core.Object.
• Minor improvements to the aspect and profiling support have been made. Fixed issue where class reference where wrapped by aspect orientation support.

Tools

Generator

There was some clean-up going on in the generator and config file area. This included some renaming and introducing of config keys, breaking existing configs. I hope everybody working against the trunk version could gather enough information from the commit messages to get their build process going again.

The generation of resource information for the build version has been decoupled from the actual resource copying, so you can run a 'compile-dist' job without the need of a previous 'copy-resources' job, and still get a meaningful result. Of course, you still need to run both jobs at some time to get a working build version in the end :). We also started to tag mandatory keys in the documentation.

Contrib

Crypto

Greetings, NSA. Given the comprehensiveness of qooxdoo, it's time to complete the framework with some JavaScript implementations typical for cryptography and encoding/decoding in general. It has popped up in the community before, but as Bill brought this up again recently, let's get this task done. All interested people are welcome to collaborate in the new qooxdoo-contrib project Crypto.

Conferences

Gee, this was a busy week. After the hectic preparation time for the Webinale/DLW 2008, the conference week was exertive as well. We had a lot of presentations and workshops, and the ominous murmurs about preparing in previous weeklies has now exploded into a sheer flood of blog posts with slide show offerings :). Do have a look through this week's posts to catch up with all of that. For your convenience, here is a quick overview:

Presentations:

• Web Application Development Workshop
• GUI Development Workshop
• GUI Internals
• BOM and Animation
• Advanced Object-Oriented JavaScript
• Web Testing
• JavaScript Tooling

Conference posts:

• First Day of Webinale/DLW 2008
• Second Day of Webinale/DLW 2008
• Webinale/DLW 2008 are over

The conference itself was not an unpleasant experience. I think we have got a few new qooxdoo fans ;). Sebastian has taken some photos and published them to flickr. You may want to have a look to get an impression of the conference.

RAP

Nearly unnoticed due to all this conference stuff the RAP team has released their second release candidate on Tuesday. For details please have a look at the list of fixed bugs.

qooxdoo-contrib

Ralf Nieuwenhuijsen has published his qooxdoo frontend for CouchDB [homepage, wikipedia], which looks really interesting. CouchDB is a schema-free, document-oriented database, which among other things means that it is not relational and does not employ tables with rows and columns. Rather, it stores your JSON data structures right away! Now, that should get you interested...

The contribution is aptly named CouchDB. From Ralf's introduction: "This contribution provides client-side access to a CoucbDB server using a REST api. For this purpose, part of this contribution is also a more generic neutral rest-library". If you are working against a CouchDB backend, this one might be for you. If you don't but are thinking about a backend persistency layer, maybe it's a good time to start looking into CouchDB.

This finishes off this week's summary. Have a good weekend, and I'll be better going before I go narcoleptic ... ;).

0.8-alpha1 release

The major highlight of this week was yesterday when we pushed the 0.8-alpha1 release out of the door, which is a preview release. If you have the chance, do have a look at it.

Timeline

There will be a public holiday here in Germany tomorrow (May 22), and most guys will be off for the weekend. Since conferences are about to start on the weekend as well, most of us will be offline until next Thursday, so please don't be surprised if things queue up a bit. During the conferences we would be really excited to meet some of you, so if you are around come to our booth or to one of the talks or workshops!

Conference demos
You are probably interested in the workshops and presentations we will present next week. We will publish all presentations on this blog after the webinale, but you already can have a look at some of the demos online.

Generator II

We added initial support for running the new generator with a native Python installation in a command box on Windows. Yes, you heard quite right, no Cygwin! Prototypal use of this feature can be seen in the qooxdoo workshop this week.

Have a good time!

Where's the beef? qooxdoo ain't no fluffy bun:

Alpha release

Work currently concentrates on getting the code base in trunk ready for the upcoming release qooxdoo 0.8-alpha1. It is planned to have it out the door by May 20, since there's another holiday here on May 22 including a long weekend. This alpha release is not feature complete yet, of course, but should already provide quite a stable base for the workshops at the upcoming ...

Conferences

Preparations for the upcoming conferences are in full gear. Have you checked out the qooxdoo talks and workshops at the upcoming conferences? It's a great opportunity to meet most of the core developers. Let us know about your plans, so that we arrange for some decently hot weather and cold drinks.

Feedreader

The feedreader was ported to the upcoming qooxdoo 0.8-alpha1. It also has got a whole lotta love to make it ready for the workshops on May 26th. We have cleaned up the whole beast, added data models, improved the GUI. The feedreader is the first application which uses the new 0.8 API. There were also some additions to the new Modern theme to support the previously incomplete appearance (not quite finished yet).

Skeleton & Quickstart

Both mini applications - being blue prints for your first qooxdoo applications - have been updated to the 0.8 API. They automatically make use of the new generator and already use the new widgets - basically just the button widget, as before ;).

Layout Improvements

Some quirks in the layout system were resolved. In particular the scrollbars got another set of fixes applied and their API was improved. Canvas layout now supports a new layout property called "edge" to easily allow to stretch a widget to all the edges (convenient for cases of top, right, bottom, left having the same value).

Resizer & Window

The window and resizer widgets were ported to 0.8. It looks quite good so far, but there are still some things open. This means that neither the API is final yet, nor is the appearance. Sub control handling for complex widgets like window is also still missing.

Splitpane widget in the works

Jonathan is currently starting with a port of the SplitPane widget. After his excellent work on the HtmlArea this actually is the first widget he ports to the 0.8 infrastructure. Be the source with you, Johnny!

Generator

This week's efforts mainly went into internal representation of global structures of the compiled application (like qxresources, etc.). Also, initial support for "contrib://"-style Manifests has been added to the "library" config key, but will see further refinement. This allows you to use qooxdoo-contrib projects in your own projects, as you already know it from qooxdoo 0.7. Preliminary documentation of the generator is available.

Now to some exciting topics outside the qooxdoo 0.8 development:

Visual GUI Builder for qxTransformer

PyQooxCard is a visual GUI builder based on the layoutEditor of the original PythonCard package. It has been extended by John Henry to support qxtransformer code generation. PyQooxCard allows you to create similar-looking GUIs for the desktop and the web - you can use the same resource files to create python executables and qxml templates. This sub project is still under heavy development, feedback is welcome.

Appearance is Everything

Great news, at long last an early adopter's release of AIE themes for qooxdoo 0.7.3 is available for download. A two page Quick Start Guide is included to help get you started. Check out the demos and please provide some feedback.

Have a nice weekend.