Another week in retrospect:

Deprecated code

With revision r23139, we removed the deprecated code introduced with version 1.2 of qooxdoo. So now trunk is completely free of deprecations again. For more details, take a look at the corresponding bug report.

Using a deputy

We had a request to add the possibility to specify a deputy as a model in the list data binding. This can be especially handy when using a list or select box within a form. The form demo now shows how to create a form including a select box, all nicely done with data binding.

Fixes

For a complete list of tasks accomplished during the last working week, use this bugzilla query.

New Contrib: CanvasCell

Tobi Oetiker did it again: another high-quality addition made it into qooxdoo-contrib:

That's what he said about CanvasCell: "Haven't you all been dying to get a chance to embed little charts into your qooxdoo tables? Looks so much more fun than all this text and numbers. The structure of the canvascell renderer makes it very easy to add your own plotter objects for creating other nice plots. If you load excanvas, this will even work on IE6-8.

Have a look at the demo source to see how to use the things. If you come up with your own plotters, I'll be glad to add them. I have made CanvasCell available in qooxdoo contrib, so you can grab your copy". Excellent!

JSConf.eu

The European JavaScript Conference is for sure going to be (again) an absolutely top-notch event, nothing less than the annual hotspot of JavaScript goodness. Of course, we just have to be there as well. If you happen to have a ticket, or are in Berlin anyway at that time (weekend of Sep. 25./26, 2010) feel free to drop us a note in advance, so we could possibly arrange for some decent qooxdoo get-together.

Have a nice weekend!

Welcome back to another regular round-up of the week.

Overflow handling

As promised last week when we announced the new overflow feature, we updated our applications to benefit from the toolbar overflow handling. We added specific code to the feed reader, api viewer and playground. To see it in action, resize your browser window and notice the toolbar items of those applications jump into a separate menu, located at the end of the toolbar itself.

Simulator: New locator type

The qooxdoo user extensions for Selenium now support a new way to identify widgets, the "hybrid" locator. This allows test developers to combine multiple different strategies such as HTML ID, XPath and qooxdoo widget hierarchy in a single locator string, e.g.:

qxhybrid=options&&qxh=[@label=Foo]

This would find a widget with the qooxdoo property label set to Foo which is a child of another widget which has a DOM element with the ID options.

Tasks accomplished

For a complete list of tasks accomplished during the working week, use this bugzilla query.

New Contrib: QxDyGraphs

Tobi Oetiker announced that he wrote "a little qooxdoo wrapper for using Dan Vanderkams wonderful dygraphs charting library from within the qooxdoo
infrastructure. It is checked into qooxdoo-contrib under QxDyGraphs". Try the demo in the contrib demobrowser. Cool (again), Tobi!

Updated: RpcConsole

Christian Boulanger "released a minor update of the RpcConsole contribution to bring it closer to strict json-rpc standards compliance. The update to json-rpc version 2.0 will have to wait until the new RPC layer is implemented (not before the end of this year), but now the console should support sending requests to strict 1.0-compliant servers (which it did not do before)". There is more information available, the code can be found in qooxdoo-contrib. There is also an online demo, you can for instance run automated tests using the "Run Tests" menu. Thanks, Christian!

Real-life example: Sava

Last but not least there was the addition of another real-life example to the corresponding wiki page: Sava is a repair center management application, which allows you to create a quote, take an order, manage customers, monitor inventories, send bills, create repair reports.

Interestingly, Sava seems to exist for quite some time now, as early versions of it were implemented in qooxdoo 0.5, then 0.6 and finally rebuilt with the latest qooxdoo versions, taking advantage of state-of-the-art features like the data binding layer. Nice theming, btw, and thanks for sharing this success story with the qooxdoo community!

That's it for today, see you again next week.

Hi all! The weekly wrap-up of happenings in and around qooxdoo is here.

Team

A new member has joined the core team here at 1&1. It's Tino Butz, and Tino is no stranger to us. We have been working together for quite some time, since Tino was formerly on the Gmx.com mail client team. As a consequence, Tino has in-depth knowledge of qooxdoo, and a lot of application development expertise as well . Welcome, Tino!

Framework

qxoo is keeping up traction. We pushed it on our demo web site as a download, and provided some cool code samples. Even custom events and single-value data binding are working. Check it out!

Toolbar Overflow

Bugs

Here is a canned query for all the issues that were resolved this week.

Inspector

We spent some time to improve our Inspector application. We fixed some minor bugs, refactored the code and also added a feature which makes it now possible to inspect Inline applications. The screenshot shows the Inspector running on our Showcase demo (which is an Inline app), with all of the Inspector windows open (Selenium, Objects, Widgets, Properties and Console - clockwise, starting top-left). So try it out .

Community

Burak Arslan has pushed out another update to his joint SOAP efforts, soaplib 0.9.2-alpha2 and qxsoap-0.6.1-beta1, which allow you to communicate complex class hierarchies between server and client app. See the details and download instructions here.

That wraps it up for this time. Enjoy your weekend!

The last couple of days we had some time to use our new qxoo package, which you might already have read about,  and did some experiments with it. All of us here in the core team like it so much we thought we had to write another blog post to show some details on how to use it on the server side.

node.js

So here we go! As a first example I want to show you how to use it on node.js. We are using classes, inheritance, properties, the event system and even single value binding in this example.

var sys = require('sys');
var qx = require('./qx-oo.js');
 
qx.Class.define("Fish", {
  extend : qx.core.Object,
  properties : {
    age: {
      event : "changeAge",
      init : 3
    }
  }
});
 
qx.Class.define("Shark", {
  extend : Fish
});
 
var fish = new Fish();
sys.print("The fish is " + fish.getAge() + " years old\n");
 
var shark = new Shark();
shark.addListener("changeAge", function(e) {
  sys.print("The shark changed its age to " + e.getData() + "\n");
});
shark.setAge(5);
sys.print("The shark is " + shark.getAge() + " years old\n");
 
fish.bind("age", shark, "age");
fish.setAge(7);
sys.print("The fish is " + fish.getAge() + " years old\n");

The output looks something like this.

The fish is 3 years old          // 1
The shark changed its age to 5   // 2
The shark is 5 years old         // 3
The shark changed its age to 3   // 4
The shark changed its age to 7   // 5
The fish is 7 years old          // 6

Surely you've seen that we are creating two classes, a fish and a shark which is a fish of course. Our fishes have one property named age. Properties, in short, are data stores with automatic generated accessors and other goodies like in this example, a change event. We create an instance of each class and play around with the generated setter, getter and events. The second to last line shows the single value binding which synchronizes the two age properties.
This should look familiar to anyone using qooxdoo, the only difference is that its running on node.js and not in the browser (This is the corresponding "browser version", just make sure you check the Log pane to see the same messages).

Rhino

Next up, let's write a script to run in Mozilla's Rhino that demonstrates the use of Mixins:

load(["qx-oo.js"]);
 
qx.Mixin.define("MBar", {
  members :
  {
    bar : function()
    {
      return "bar!";
    }
  }
});
 
qx.Class.define("Foo", {
  extend : qx.core.Object,
  members :
  {
    foo : function() {
      return "foo!";
    }
  }
});
 
qx.Class.include(Foo, MBar);
 
var foo = new Foo();
print(foo.foo()); // "foo!"
print(foo.bar()); // "bar!"

Again, with the exception of the Rhino-specific load and print statements, this is plain qooxdoo. Assuming that js.jar (the Rhino Java archive), qx-oo.js and a file containing the code listed above, named e.g. test.js, are all located in the same directory, this is the shell command that will run the script in Rhino:

java -cp js.jar org.mozilla.javascript.tools.shell.Main test.js

If you want to give it a try you don't have to download the SDK and build it yourself. Just go to our devel applications page and download the precompiled script in either an optimized or unoptimized version. This will be updated usually once a week on Friday, like all other qooxdoo online apps.  While this qxoo package is still in experimental state, the code it contains is rock solid, having been used for a couple of years in the browser. Give it a try and send us your feedback!

Hi all! After an exciting week, here comes the usual round-up.

qooxdoo Releases

This week saw the joint release of qooxdoo 1.2 and 1.1.1. Hope everybody is enjoying it .

qxoo

We have managed to build a single JavaScript file including the whole qooxdoo OO layer which can be used in non-browser environments. See more details in the corresponding blog post.

Framework

You can now set windows to be always on top of other windows (using the Window.alwaysOnTop property) and customize default validator error messages (qx.util.Validate.*). If a widget is disabled and has a tooltip, the tooltip isn't shown anymore.

Contribution Demobrowser

As already mentioned in a separate post, we've published the new Demobrowser for contributions as a showcase for the many cool projects in qooxdoo-contrib.

Community

Soap client 0.6.0-beta5

Burak Arslan has released soap client 0.6.0-beta5, which goes together with his Python based soaplib 0.9.1, the server-side SOAP library. Writes Burak:

Node.js

node.js and similar non-browser JS environments received a lot of attention on the mailing list recently. qxoo plays in this direction. In the course of the discussion Christian Boulanger came up with a new NodeSocket contribution. Christian wrote:

See his mailing list announcement for full details.

That's it for this week - see you around next time.

It has been a topic a couple of times on our mailing list, to bring the OO layer of qooxdoo to non-browser environments. I took some time after the last release to check what's necessary and build a proof of concept. That went so well that I included it into the framework to make it accessible for everyone. You can build your own qooxdoo OO package by just using a new introduced generator job in the framework folder:
./generate.py build-qxoo
That job generates a simple but powerful JavaScript file including all the qooxdoo OO goodness including classes, interfaces, properties, ...
My intention was to build a file which can be used in a web worker, for example for running unit tests. But I did also test the file on Rhino and node.js, which are two JavaScript implementations outside the browser, and it worked there just as well.
It still is only a proof of concept but if you are interested give it a try and give me feedback.

We are happy to announce another joint release of the qooxdoo framework. You can download versions 1.2 and 1.1.1, the corresponding release notes and manuals are online as well.

The qooxdoo 1.2 release comes with substantial improvements in almost the entire range of the framework. Here is a brief overview:

• The entire manual is now in SVN, using reStructuredText as markup. It is delivered with the SDK as HTML and also as a PDF document for offline reading (about 400 pages).
• A new virtual List was added, which can handle really large numbers of items. It takes full advantage of qooxdoo's data binding layer, so another demo shows how you can create an extended list with custom renderers. The virtual List is marked as experimental, and we look forward to include user feedback as we continue with the development of additional virtual widgets.
• As another preview we added a Selenium window to the cross-browser Inspector to aid in developing automated GUI tests for qooxdoo applications.
• The API Viewer API Viewer now allows you to open distinct tabs for any class or package description. Just press “shift” or “ctrl” when mouse-clicking on a reference.
• Many handy features made it into the release to support your work as app developers, e.g. generating API doc files for dedicated classes by a single command, including child control info with the API reference, several optimizations in the toolchain, more configuration options for the generator, experimental Jython support, real-time logging in the Playground, and so on.
• More than 200 bugfixes and enhancements over the previous release.

At the same time, and following our release scheme, we're releasing an 1.1.1 version, which is a regular patch release of the 1.1.x branch and contains only bug fixes. It can be used as a drop-in replacement for anybody using 1.1, and users of these versions are encouraged to upgrade, i.e. if they don't upgrade directly to 1.2.

Many thanks from the core developers to the community of contributors and users, who helped making these versions the most advanced releases to date. Enjoy!

As you surely all know, qooxdoo-contrib is the project's place for hosting various contributions and therefore a vital part of the qooxdoo ecosystem. We always try to improve things there, so here's a preview of a feature we've been working on for quite a while now.

There's a lot of great projects in qooxdoo-contrib, but the only way to try them out for yourself is to check out the repository and build the demo application (if the contribution provides one) or, failing that, to include the library in a project of your own. Fairly time-consuming for a quick evaluation.

That's why, as another step towards making qooxdoo-contrib easier to use, we created the Contribution Demobrowser, which is exactly what it says on the tin: A variant of the qooxdoo framework Demobrowser that lists contribution demos.

If you're a contribution maintainer, here's what you can do to have your project showcased in the Demobrowser if it isn't already:

Eventually, we plan to have the contrib Demobrowser automatically update and publish itself at regular intervals. Please note that currently we limited the demos to contribs that are in a fairly consistent and up-to-date state. For the time being we also focus on demos that have purely visual frontend content, so none of the typical utility classes, backends or tooling contribs are included, which are a separate topic.

Starting with a subset of contribs we can continue to work closely with their contributors to further improve the contrib demobrowser and the consistency and completeness of contribs. All (prospective) contributors are welcome to try out the demobrowser themselves, see the readme file in the qooxdoo/contribDemobrowser checkout of qooxdoo-contrib.

We hope such a contribution demobrowser allows to bring contribs to more people's attention, helps authors to improve their existing contribs and encourages users to provide more high-quality contribs. As it is an early preview there obviously is much that could be improved, we're well aware of that. But if you could give specific feedback to the current state of the contribution demobrowser, what you like about it and how well you're doing in getting your contribs to run in it, that would be much appreciated.

Another weekly status report right before the releases planned for next week.

Upcoming Releases

This week we continued and intensified our efforts towards the upcoming releases. According to our release scheme, it is again a joint release of a minor release (qooxdoo 1.2) and a patch release (qooxdoo 1.1.1). The ramp-down plan has already be announced on the mailing list, with a preliminary target date Aug 4, 2010 for both releases. We are currently in the phase of testing the two release candidates thoroughly, adding reports to the bug tracking system, and trying, if feasible for the releases, to resolve issues. As we are busy testing and finalizing the releases, attendance to the mailing list might decrease. Anybody on the list is encouraged to help out by trying to answer other people's questions.

Deprecations

We took the time to remove all old deprecated code before the upcoming 1.2 release. If you are interested in details about what has been removed, take a look at the corresponding bug report. Special thanks to all people who tested their apps with the latest trunk and reported back that they didn't find any issues: Fritz, Burak, sub, Daojun, Werner. Much appreciated!

Windows, Validation, Tooltips

Some of the work on the framework included fixing and/or enhancing certain features: You can now set windows to be always on top of other windows (using the alwaysOnTop property) and customize default validators' error messages (see qx.util.Validate.*). If a widget is disabled and has a tooltip, the tooltip isn't shown anymore. Particularly nice about those improvements is, that they were done by our new Romanian colleague Adrian, who just recently joined us for framework development. Keep it up!

Bugfixes

Quite naturally for the last coding week before a release, we achieved to resolve quite a number of open bugs. For a complete list of bugs fixed during the last working week, use this bugzilla query. No need to worry, though, there are enough issues left for future releases.

So, keep your fingers crossed for some successful release ramp-down, and stay tuned for more info.

I've just returned from Birmingham where EuroPython, the European Python conference, has been held for the second time in successive years. The organizers have done a tremendous job to make it a friendly and productive conference. I attended the preceding tutorial days, taking a full-day tutorial on py.test by Holger Krekel, a half-day introduction to Google App Engine by the venerable Wesley Chun, author of Core Python, and a half-day tutorial about TextTest held by Geoffrey Bache. All of them were excellent.

During the main conference which lasted from Monday through Thursday I focused on presentations relating to code quality and performance. Highlights for me were Raymond Hettinger's Idiomatic Python who was given another free time slot to cover more material, and the talks about virtual machines (PyPy, HotPy). Guido van Rossum, Python's "Benevolent Dictator for Lifetime", gave a very insightful questions-and-answers keynote session, where he addressed many issues both interesting and relevant for Python's future. Concerning one of them, which is also very close to my own heart, he mentioned that he is interested in high-level concurrency constructs and is attending all CSP-related talks in the conference (e.g. [1], [2]). There was also a CSP-related sprint in the days following the conference. I think this is a very important field, and has to be covered in good manner in Python. One other thing that struck me was the way people twist and bent Python, using its meta programming facilities, as e.g. Kay Schlühr demonstrated with Langscape, a framework to define language extensions which get translated to standard Python. There were also two lightning talks sessions which were a very good way of presenting interesting topics to a large audience in a few minutes.

During the conference there was also the first meeting of the PSF ever to be held outside the US. The PSF, the Python Software Foundation, is the non-profit legal entity behind Python that holds the intellectual property rights and tries to promote and protect the language. Twenty non-members where invited to attend and I managed to slip in. It was an interesting insight into the inner workings of an international open-source organisation. All in all it was a very interesting and enjoyable conference, with lots of contacts and chats during breaks and in the after-conference evenings. Way to go, EuroPython! (Ah, I wish they would rename it into PyCon Europe).