Those of you who have an interest in the SQL functionality of Qt may have seen my name floating around a bit for the last year or three. I’ve taken over the care and tending of the SQL subsystem. Sometimes you have to make hard decisions. Decisions to prune parts of the garden that you’ve taken into your care. One of those decisions is coming up for the 4.7 release.

The QTDS driver is in dire need of a full rewrite or a deprecation in favour of another system that provides equivalent functionality. As QODBC offers that system, we’ve decided that this is the path to go down. The biggest problem with the driver is that it’s based upon the very old, and across the board very neglected db-lib interface. Sybase, Microsoft, and FreeTDS have all marked this interface as legacy and unsupported. Further down the track (especially if someone feels generous enough to provide this as a code contribution), QTDS may resurrect, rewritten with the ct-lib interface, but seeing as QODBC provides all the functionality we need this is an unlikely state of affairs.

Please feel free to discuss, we are listening, and would like your opinions on this matter.

Our friends in Brazil have released PySide, Python bindings for Qt.

PySide is a project that is run by INdT and sponsored by Nokia that provides Python bindings for Qt under the LGPL. These bindings are currently in pre-release form and only support Linux/X11, however the PySide team is hoping the community would be interested in helping to make the bindings cross-platform. The team is happily awaiting your feedack and contributions.

Head over to PySide.org and learn more.

Right now there is the “Gran Canaria Desktop Summit” which is basically GUADEC + Akademy glued together. We’re a bunch of Trolls down here basking in the sun, discussing, and socialising with the KDE and Gnome and other open source developers who also took the trip to this beautifull island.

Today we had the opening with keynotes from several people:

Robert Lefkowitz told us that software is rhetorics, and that liberal software is what a gentleman would use.

Walter Bender took us for a trip around the “Sugar Learning Platform”.

And, RMS distributed penance and blessings to the evildoers and saints of the software world. Here is a summery:

• Qt is now perfectly OK (allthough he still can’t pronounce it correctly)
• Apple is about as evil as Microsoft, but they’re not publicly admitting to it.
• C# is dodgy, and
• Web-services are evil.

Then finally, Quim Gil gave us an update on the Maemo platform.

As I said, we’re a bunch of guys from Qt Software down here in Gran Canaria, so if you’ve got any Qt issues you wanna discuss, feel free to grab one of us at any time. You will recognise us by the black Qt polo-shirts we’re wearing. Some of us are also hosting presentations, check out the program here.

We’re here for about a week, so expect some more posts

After three incredibly short months, the Qt to S60 porting team is pleased to provide another pre-release of the port! This time, the pre-release code name is “Tower”. Nearly all functional areas which are wrapped by Qt’s beautiful Api are now doing their job also on S60.

Red carpet
The red carpet to S60 development with Qt is now rolled out for You. Despite some tiny roughness here and there, Your walk over that carpet should be safe and pleasant. In other words: If You did not already, this is the perfect time to start playing with Qt for S60

What’s new?
Besides the usual optimizations, fixes, code cleaning and various improvements, there are three fresh modules: Phonon, QtSql and QtWebkit, new softkeys and input methods APIs, as well as a brand new installer.
Phonon on S60 is building and applications that are built against it will run, but there is currently no functional Phonon backend on S60. QtWebkit on S60 is still considered experimental. However, You should already be able to start developing QtWebKit refined applications for the pocket. A complete list of changes can be found here.

In addition to the new features, work has also begun on making Qt exception safe, in order to fill the gap between Symbian and Qt exception systems. You can read more about Qt and exceptions here.

Installation is easy!
This release makes the installation of Qt for S60 easy. An installer will copy the Qt libraries (for emulator and hardware) to the places where they belong. Start using Qt, right away, the dark ages of required manual Qt builds are over.

Getting started
We at QtSoftware love to create videos. This time, we have three of them showing some demos and how to get started:

Qt for S60 is getting close to being feature complete, and is also much easier to install than before. We really think that this release makes it worth walking the red carpet!

That’s right.

This weekend we integrated the animation and state machine APIs (part of the Qt Kinetic project from the road map) in Qt’s master branch.

They were both released as solutions before, and we’ve had a lot of feedback. The APIs have been through a bunch of reviews and iterations, and we’re really really proud of the results. So go and pull the latest version of the repository and try out the examples and the examples.

I’m not going to say any more about it, rather I’ll just link to a bunch of blogs that we posted earlier. (PS. some of these have screenshots and even videos)

Qt Animation Framework.

Welcome to Kinetic.

Qt State Machine Framework.

Qt Kinetic hits Plasma.

Animated Layouts with Qt Kinetic.

Qt Animation Framework reloaded.

Animated Tiles.

Qt Hierarchical State Machine Framework add-on released.

New (and last?) QtAnimationFramework Solution (wasn’t the last, by the way.)

Writing a game with the animation and the state machine API.

A full serving of the Qt State Machine Framework.

Qt Animation Framework 2.3 is out.

It’s taken a little longer than expected, but the nice and polished Qt Jambi 4.5.0_01 packages are finally ready for download on Qt Software’s server. As usual, there are both source and binary packages available, but to match the new licensing of Qt, the GPL packages have been replaced by LGPL packages this time around. Read the press release.

As has been announced earlier, this will be the final feature release of Qt Jambi from Qt Software. Patch releases and support will continue for the next year, but when Qt 4.6 comes out, Qt Software will not be releasing an official Java version. Part of me is sad about this, sure, but part of me is excited as well, because with the new licensing terms, I think there is a real chance that Qt Jambi can become a success in the wild and continue to grow, maybe even at a quicker rate, in both stability and popularity and excellence, after the official support for it has ended.

This success relies on one thing in particular: Our ability to establish a community of volunteers who want to maintain and use Qt Jambi when its official life as a Qt Software product ends. Having this community is vital. It’s what will make or break Qt Jambi in the future, so we want to do what we can to get that going.

The first step is of course to license the product under the LGPL. This means that both open and closed source users can continue to use the product.

The second step we are taking is to host a public git repository for Qt Jambi. People who wish to contribute to Qt Jambi can clone the repository and request merges to master when they feel their changes are ready for it. We will maintain the public repository for the coming year, and integrate changes that are deemed safe/tested and that pass whatever legal criteria might be required (I don’t have details on this yet, so lets call everything subject to change.)

As a third measure, we have made sure that the repository is complete, meaning that it contains the revision history from the very moment we took Qt Jambi out of research and made a product branch of it. The inner workings of Qt Jambi are complex, so being able to do a “git blame” and find the change description that explains exactly why, for instance, a particular function requires a recursion guard or a mutex lock, is a requirement when new maintainers take over control.

Fourth: As many of you know, we have always tried to keep a direct line of communication with users. So far this has been using the Qt Jambi Interest mailing list, and that will continue unless the community takes its discussion elsewhere. In addition, I want to make available as much information as possible on the processes we have established and experience we have gained while working on Qt Jambi for the past years. My current thinking is to put this here on labs in the form of blogs, but as the amount of information grows, a wiki might also be in order.

Finally, if you are interested in contributing to Qt Jambi, and you have any questions/ideas on how we can make it a success as a community project, please sign up to the mailing list and let us know. Also, clone the repository at http://gitorious.org/qt-jambi and start hacking!

With the announcement back in January of Qt going LGPL there was a small piece of information that slipped though the cracks of the wider news reporting, namely the fact that we were planing on opening up our repositories and development model. The first major phase of this work is now complete, and we are proud to present the results:

Launching a public repository is a big milestone for us in Qt Software, as it allows us to work closer with contributors, strengthens the the link to the community, and gives that warm and fuzzy feeling of working with open source. Granted, our releases have been open source, but our development model has not. Although you could always send us patches by mail or through our bug tracker it was a cumbersome process, requiring a faxed copy of a copyright-assignment form from the contributor, as well as a lot of manual labor on our part.

Our goal with the new site is to make this process as simple and welcoming as possible, and that’s why we will no longer ask for copyright assignment. Instead we ask contributors to grant Qt Software a non-exclusive right to re-use and incorporate the code as a part of Qt, handled by a one-time online click-through the first time you submit code for inclusion in Qt.

Maintaining your patches to Qt and working in parallel with our development is also very easy thanks to the features of Git and Gitorious. Just clone the official Qt repository, push you changes to your newly created clone, and submit a merge request for our reviewers. Everything happens on the site. (For more information on how to contribute see the Qt project wiki).

Choosing Gitorious as the basis for our public repository hosting was the result of both chance and strategy. As previously blogged about we switched to Git for our development almost a year ago, and as part of the move we installed Gitorious on one of our servers to manage our many projects and repositories. We soon started hacking on the code to add various features and tweaks, and quickly fell in love with the codebase. Fast forward a couple of months to the LGPL and public repository planning, we started playing with the idea of using Gitorious for hosting the public site too. At that point we realized that the author and maintainer of Gitorious, Johan Sørensen, was actually living in Oslo, so we invited him to our offices for a chat. One thing lead to another, and we ended up funding Johan and one of his colleagues to work on Gitorious for the past four months. The new Gitorious site is the result of that work. All of our changes have been pushed upstream, and we will continue to invest in further development of the site.

So what are the features of the new site? Johan has already enumerated these in full on his blog, but a few highlights are in order:

• Team support (easier to manage committers and project ownership)
• Asynchronous task processing (no more lag when pushing)
• Visual tweaks (including breadcrumbs and pretty URLs)

We are also looking at improving the whole review process, for example by adding line-based commenting to merge requests, bug-tracker integration, and automated testing of contributions, but these are ideas still in research. Stay tuned for updates on this.

So, what are you waiting for? Create an account on Gitorious, start cloning, and join the exciting development of Qt!

Good luck!

Today we is a day that will be remembered for a long time in Qt history (I expect that we’ll remember it all the way until next week at least — that’s at least a thousand commits). I made today two 280,000-line changes to Qt, touching over 6500 files in each. At the end of the day, three Qt branches (4.6, 4.5 and 4.5.0) now contain the LGPL license header in all Qt’s .cpp and .h files, plus an assorted set of scripts. Third-party code is obviously excluded from this change. That means the GPL era of Qt comes to its end — and LGPL starts.

Today, I stopped the cron job that creates and publishes the Qt snapshots. Mostly because the LGPL and other changes are very likely to break stuff. And that we don’t want the snapshots published under the LGPL until we actually release 4.5.0 next month. What’s more, I don’t know if snapshots will ever come back: maybe we will go directly to the open repository. That’s the end of the snapshot era.

Today, Alexis also made changes to the Qt repository in Git, removing the never-released files and adapting the the license files. He also refactored the license part of the configure script and the Windows configure.exe (it’s a good thing that I turned snapshots off, because he went to ski shortly afterwards in a classical example of “submit-and-run” ). That’s one of the last steps required for the open repository, though there are a few minor things to go.

This week, the temperature in Oslo reached 0°C again. That means the snow is starting to melt and the streets are very dirty now. The mountains of snow that we have collected over the past few weeks will gradually disappear. That’s the end of Winter, but I hear it will come back (I don’t put too much faith in those rumours).

This month, I’m also stepping down as Release Manager for Qt. I had pre-announced this at Developer Days last year, but it’s effective now: after 18 months and releasing Qt 4.3.3, 4.3.4, 4.3.5, 4.4.0-tp1, 4.4.0-beta1, 4.4.0-rc1, 4.4.0, 4.4.1, 4.4.2, 4.4.3, 4.5.0-tp1, 4.5.0-beta1, 4.5.0-rc1 (and two mac-cocoa alphas), it’s time I pass the torch to the next poor sob brave soul to take on the job. So this is also the end of my era as Release Manager. (No, I’m not leaving Qt Software, I’m just moving on to other responsibilites)

It’s interesting to note that the change in RM matches the change in environment. It’s tradition that each new RM gets to rewrite the release scripts from scratch. The RM before me had all of it working for our setup with Perforce. I rewrote it to use Git. After me, you can’t call them release scripts anymore, because I rewrote them in C++, using memory-mapped files and QtConcurrent. Now my successor will have the chance of rewriting it to match the open repository. It looks like packaging will be a lot simpler, since there will be no file editing or removal.

This is not a sad time. At least, I haven’t seen anyone crying their eyes out in the office. So I must conclude that this is a happy time: the end of an era marks the beginning of a new one. We can only hope that the new era will be even better than the current. We’re certainly going to make our best effort.

Disclaimer: this blog could be part of a conspiracy against Qt on Windows.

We’re finally there! The long-awaited Qt 4.5 release candidate is out! Downloads are available through the QtSoftware website. For the impatient, I’ve copy/pasted the download table here:

Note to self: ask webmaster to use the same CSS theme in both Labs and in the main website

We’ve done lots of work in performance and we added the pluggable graphics system support. Performance on the native and raster engines should be much better than it was before. Performance work also touched Graphics View (clipping, scrolling) and went even as far down as URL-parsing in QUrl

We added support for 64-bit applications on the Mac with Cocoa — though you can use Cocoa in 32-bit too. I don’t know why, after all you have more registers in 64-bit (that’s what Apple tells anyways).

We upgraded QtWebKit to upstream trunk, bringing in some HTML5 features as well as Netscape Plugin support, meaning you can finally see ads on websites (who knows, you may even be one of those who click on them!). By integrating QtWebKit with Phonon, we added support for <audio> and <video> tags, without the need for a Flash video player.

We also upgraded Phonon to the latest release (4.3.0), though this technically means we’re making a new release of Phonon (4.3.1). The QuickTime 7 / QTKit backend for Phonon got an overhaul and was rewritten in Objective C so that it can be built in 64-bit mode too. We also added a new, very simple backend called “waveout” for Windows CE devices that have no codecs or DirectShow.

QtScript got a debugger, both in the form of an API (see the QtScriptTools module) and a graphical debugger.

And one of my features has finally made it to the news page: improved proxy support.

Thanks to all the trolls who did amazing work for this release and to all contributors who sent us patches, ideas and feedback. We’re releasing at an all-time low of Priority 1 tasks left, but feedback is definitely welcome. Please post your feedback to the qt4-preview-feedback@trolltech.com mailing list and we’ll be sure to address it as soon as possible.

Edit: Qt Creator 0.9.2 RC is also out!

If you read any KDE news you will have heard that there was a KDE conference last week in the Americas called Camp KDE. The yearly KDE conference in Europe has sparked interest on the other side of the ocean. With a growing community all over the Americas the idea for having a local conference makes a lot of sense. At QtSoftware we naturally like this, and so we made sure several Trolls traveled to the Caribbean and joined in on the fun.

I talked about locations of Akademy (the European KDE conference) on various occasions. One suggestion we had was to do it way up in Sweden when there was expected to be 2 meters of snow and temperatures that would keep even the most adventurous geek inside. The idea here, naturally, is that with such conditions you will do more actual coding and hacking and less wasting of time on other things.
I’m so happy this never happened since I see that the opposite is even more productive. Geeks going to Jamaica, with sun, beach and parties, are still just geeks. I don’t think I’ve seen any geek spent a long time sunbathing. After not very long of relaxing on the beach, swimming in the ocean geekyness returned. We had BOFs while swimming, programming on the beach and lots of discussions about Qt / KDE coding.

In the end we actually did quite some work; you can find lots of pictures of people leaning over laptops on flickr and Alexandra Leisse who is also with both KDE and QtSoftware had the presence of mind to bring a video-camera. Have fun watching geeks on the beach here