Declarative UI is one of the big things on the Qt Roadmap for Qt 4.7 and 4.6.x. I already enjoyed working with the Qml language and the developers behind it for quite some time - and believe me, this one will fundamentally change the way slick Qt UIs are designed and look like! If you have not checked it out yet, do so … although it is not yet part of the Qt package, it is very mature, and just fun to experiment with

Anyhow, a technology like this of course does not come out of the blue, neither do the tools to support it - I think the first discussions about a Visual Editor for a language yet-to-be-invented on the basis of the QGraphicsView framework started in summer 2008! In early 2009 I first heard about the name “Qml”, and was soon the lead of a development project, with right now 5 people working full time in this project. One of the most important decisions we had to make early on was for a cool project name - we eventually settled for “Bauhaus”, as a reminiscence to the famous German school for design.

Back to the facts: What I want to share with you today are our plans for supporting Declarative UI / Qml in QtCreator. This is an important one, because with Declarative UI we target not only the traditional Qt/C++ developers, but also more design centric people - the goal is to let both share the same language, from early prototyping until the final product. We can only achieve this with good tools in place.

Here are the things we are currently working on for the next major version of QtCreator:

Qml Text Editor - We already have some basic syntax highlighting / formatting support in QtCreator 1.3, but in the QtCreator master branch we are right now working on really mature Qml/JavaScript support. This will include all the goodies you kind of expect these days: Code completion, context sensitive help, …

Visual Qml Editor - After all, we are talking about graphical user interfaces, and you will not make UI designers happy just with a text editor . Here we decided for a fresh start and developed the components for the Visual Editor from the ground up. Interestingly, we are using Qml heavily ourselves here - e.g. in the Property Editor and States View.

Seamless Integration - It is no either text, or visual editing: You want to use both, and quickly switch between both. This is why we deeply integrate the Visual Editor into QtCreator, share the same Undo/Redo history and are also preserving the Qml file formatting as much as possible when doing file changes.

Debugging - We integrate the Qml debugger, which allows you to inspect the qml item tree and its properties at runtime, to check framerates, to evaluate JavaScript expressions and so on inside QtCreator.

Enough said - Nigel recorded a nice video showing you how the support currently looks like:

If you want to try it out yourself, we also packaged a technical preview of creator, qmlviewer/qmldebugger and the declarative examples & demos in one installer:

qt-creator-win-opensource-1.3.80-qml-tp1.exe (Windows 32 bit)
qt-creator-linux-x86-opensource-1.3.80-qml–tp1.bin (Linux 32 bit)
qt-creator-mac-opensource-1.3.80-qml-tp1.dmg (Mac OS X)

Disclaimer: The binaries are unsupported, and are only meant for early testing. In fact they are based on an untested snapshot of Qt, and an (almost) untested version of QtCreator! If you want to use qml for production work, stay with QtCreator 1.3.1.

Of course we are interested in all kind of feedback, preferably via the bug tracker or on the qt-creator mailing list.

Since new Qt 4.6.1 and Qt SDK 2010.01 packages have been released just today, we want to take this opportunity to also make an updated version of Qt Creator available.
This is a pure bug fix release, so don’t expect great new features in this version (these are secretly developed on the master branch on qt.gitorious.org ), but definitely expect great improvements in various areas.

Most notably, debugging on Mac OS Snow Leopard has received some badly missing love, as well as several more general debugging improvements. Also, the C++ editor has been tweaked a lot, see the more complete list of changes.

Download the Qt Creator 1.3.1 package now!

Remember the day when you were asked to remember the days when all the tools at hand looked like a Basic interpreter with 30 commands, the most usable being PEEK, POKE and PRINT?

That’s been almost half a year now, and the tale is ready to get a new chapter.

The latest and greatest in the World of the GNU Project debugger (also known as gdb) is Python scripting, — and it is really awesome. I certainly don’t tend to exaggerate on the positive side, but this is close to sliced bread with chocolate and beer. Erm… well, you get the idea

The feature has been in the works for a while (the initial commit to the gdb CVS repository was in August 2008) and was officially released with gdb 7.0 in October 2009. So in theory it is now in a usable state and accessible on a broad range of platforms.

Unfortunately, outside the Ivory Tower usability is a bit hampered by the fact that gdb 7.0 likes to divide by zero every now and then, and the “broad range of platforms” excludes Mac (Apple’s gdb for Mac is based on FSF gdb 6.3, and FSF gdb does not work there), Symbian (best bet so far is based on FSF gdb 6.4), and, of course, MSVC compiled binaries on Windows (no gdb at all).

But a few Gaul villages are still standing: It does work on Linux, and after tickling the gdb sources a bit it even works well, so well in fact that the next release of Qt Creator will use gdb’s Python scripting to build up the “Locals and Watchers” view.

This also lets us nicely address one of the most prominent feature requests: To “provide hooks so that users could write their own display classes for custom data types to totally do away with the need for printf-style debugging”, or “an easy to use plugin interface for the display of custom object”, or “a nice custom data type display interface would be for the user to implement” (see comments of Ben, Abdel, and spinynorman), or a few similar ones on qt-creator@trolltech.com

Here is how:

1. Get a Python enabled gdb by either
   • downloading a pre-build binary from here

   –or–

   • building one yourself:
     • get build prerequisites including Python development packages (on Ubuntu e.g. python2.6-dev)
     • get gdb sources from the archer-tromey-python branch:

          git clone git://sourceware.org/git/archer.git
          cd archer
          git checkout -b archer-tromey-python origin/archer-tromey-python

     • patch sources to work around that division by zero:

          --- a/gdb/value.c
          +++ b/gdb/value.c
          @@ -1920,7 +1920,8 @@ value_primitive_field (struct value *arg1, int offset,
                 v = allocate_value_lazy (type);
                 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
          -      if ((bitpos % container_bitsize) + v->bitsize < = container_bitsize
          +      if (container_bitsize
          +         && (bitpos % container_bitsize) + v->bitsize < = container_bitsize
                    && TYPE_LENGTH (type) <= (int) sizeof (LONGEST))
                  v->bitpos = bitpos % container_bitsize;
                 else
          

     • configure and build it:

          ./configure --with-python --disable-werror
          make

       Your new gdb will emerge as gdb/gdb. It will identify itself as gdb-6.8.50.something-cvs. That is fine.

2. Get a recent checkout of Qt Creator master branch and build it:

      git clone git://gitorious.org/qt-creator/qt-creator.git
      cd qt-creator
      qmake -r
      make
   

3. Point Qt Creator’s gdb path (Options -> Debugger -> Gdb -> Gdb Location) to your archer gdb or set the QTC_DEBUGGER_PATH environment variable before starting Qt Creator.
4. Start debugging as usual.

That gives you the kind of display of QStringList, std::map etc use are used to from the old C++ based debugging helpers. You might notice that it’s even a bit quicker. Nothing to be scared about, though.

But now, time for your own debugging helpers. Assuming you have the following class template in your code:

  template <typename T> class Vector
  {
      public:
         explicit Vector(int size) : m_size(size), m_data(new T[size]) {}
         ~Vector() { delete [] m_data; }
         //...
      private:
         int m_size;
         T *m_data;
  };

all you need is to

1. write the following into some file, say vector.py:

       def qdump__Vector(d, item):
           data = item.value["m_data"]            # extract the 'm_data' member from the object
           size = item.value["m_size"]              # extract the 'm_size' member from the object
           d.putItemCount(size)                       # set the 'value' field to '< %n items>‘
           d.putNumChild(size)                         # announce ’size’ children
           if d.isExpanded(item):                      # check whether the children should be shown, too
              # start writing ’size’, but no more than 10000 children.
              d.beginChildren([size, 10000], item.value.type.template_argument(0))
              for i in d.childRange():                   # iterate over the specified range
                   # create a new item from a value obtained from dereferencing the
                   # data pointer, with an internal name composed of the parent’s
                   # internal name and the current child number
                   d.putItem(Item(data.dereference(), item.iname, i))
                   data += 1                                 # advance the data pointer by one
               d.endChildren()                            # end writing the list of children
   

2. make it accessible to gdb:

      echo "python execfile('/path/to/your/vector.py')" >> ~/.gdbinit

3. start debugging as usual

Qt Creator’s default helpers are defined in share/qtcreator/gdbmacros/gdbmacros.py. For a description of the two parameters ‘d’ and ‘item’ (of type ‘Dumper’ and ‘Item’ respectively), refer to tomorrow’s Qt Creator documentation (just git pull again after 22:00 GMT). Don’t forget to run make qch_docs and to point your Options -> Help -> Documentation to share/doc/qtcreator/qtcreator.qch if it’s not showing up immediately.

Have fun!
André

The Italian guy with German accent made new videos This time it is a whole trilogy about Qt development targeting the Symbian Platform:

1 - Setting up a Symbian/S60 development environment

Bullet proof guide to how to install and plug together all those different components that make up a Symbian/S60 development environment. Download links: ovisuite, carbidecpp, activeperl56, s60sdk, openc and apptrk.

2 - Setting up Qt for Symbian

The easy part: How to install Qt for Symbian on PC and phone, and also a Qt SDK for Windows in order to have QtCreator plus desktop Qt.

3 - Developing in Qt Creator

The fun part: How to develop a Qt application first on the desktop and then deploy and debug(!) it on the device. All in Qt Creator, with its preliminary Symbian support.

The end of the year is usually a time where people reflect on the past, think back, and drink a lot of beer/wine/apple juice in the process. When I do that now (ah, no beer or wine though), I can only say: Wow. What a year.
Qt went LGPL, Qt Creator 1.0 released, the source repositories went public on qt.gitorious.org opening new possibilities for contribution and collaboration, the new public bugtracker was established, and now Qt Creator already comes in version 1.3 (together with Qt 4.6), with lots of changes, improvements and extensions to the original 1.0 release. And that’s only the Qt Creator centric view .

So to wrap this amazing year up, we today released Qt Creator 1.3.0, with a rather impressive list of features:

• Experimental support for development of Qt for Symbian applications
• First refactorings:
  • Renaming symbols
  • Find usages of symbols
• Color schemes for the editors:
  
• Automatic matching of brackets and quotes:
  
• Support for the Microsoft Visual Studio compiler tool chain for cmake projects
• Better support for small screen sizes
• Locator filter for symbols in the current document
• Many more

Of course, we haven’t been resting in the last few days, polishing Qt Creator for the final release: Since the release candidate 18 little fixes went in, plus updated translations, like the French one that was blogged about in a different post. As mentioned in the blog, translating Qt Creator is not something you’d do on a friday afternoon. Great many thanks to all who put their precious time into making our beloved software even easier to use :).

Download Qt Creator 1.3 or the 2009.05 SDK (includes Qt 4.6.0 and MinGW 4.4) from here. If you prefer to use the Microsoft Visual Studio compiler, get the new Qt for Visual Studio 2008 Open Source package.

A few weeks ago, we had an awesome insane idea: to translate Qt Creator into French. It turned out to be a terrible idea, because it was much more work than what we originally thought.

We started to translate the strings and it didn’t take us long to realize how huge Creator really is, and the list of strings to translate seemed endless. We ended up asking for help in one of the French Qt communities, Qt.developpez.com. Their response was amazing, they worked like crazy on the translations, and thanks to them, the next version of Qt will provide a French version of the tools. From Qt 4.6.0 on, you will have a French version of Qt Designer and of Qt Assistant. Qt Creator 1.3.0 is available in French entirely, including the integrations and the less known plugins.

The translation of thousands of strings, by non-profesionnals, in only a few weeks, have been quite a challenge :). Thanks to Jonathan Courtois, Alp Mestan, Florent Renault, Pierre Rossi for their amazing work on translations. Thanks to Yoann Lopes for the review of some of the tools.

Thanks to great efforts from the community, Qt Creator has translations for German, Spanish, Italian, Japanese, Polish, Russian, Slovenian and now French. Everybody is welcome to participate in those translations or to create a new translation via the GIT repository on gitorious. If you would like to help the French translation, you are welcome on the forums of developpez.net to meet the other translators.

---

Il y a quelques semaines, nous avons eu une idée géniale stupide : traduire tout Qt Creator en Français. Il s’est avéré que cette idée était ingérable, car cela représente bien plus de travail que ce que nous avions initialement imaginé.Après avoir commencé la traduction, nous avons rapidement réalisé à quel point Creator est immense, et la liste des chaînes à traduire semblait sans fin. Nous avons demandé de l’aide à l’une des communautés Qt francophone: Qt.developpez.com. Leur réponse a été incroyable, ils ont travaillé comme des fous sur les traductions, et grâce à eux, la prochaine version de Qt aura une version francophone des outils. À partir de Qt 4.6.0, une version française de Qt Designer et de Qt Assistant. Qt Creator sera disponible intégralement en Français, y compris les plugins dont personne n’a jamais entendu parler…La traduction de milliers de chaînes de charatères, par des amateurs, en quelques semaines, a été un véritable défi :). Merci à Jonathan Courtois, Alp Mestan, Florent Renault et Pierre Rossi pour leur travail sur les traductions. Merci a Yoann Lopes pour la vérification des traductions des outils.

Grâce aux efforts de la communauté, Qt Creator est traduit en Allemand, Espagnol, Italien, Japonais, Polonais, Russe, Slovène, et maintenant Français. Tout le monde peut aider à ces traductions, ou créer de nouvelles traductions, via le dépôt GIT sur gitorious. Si vous désirez aider la traduction française, vous êtes les bienvenus sur les forums de developpez.net pour rencontrer les autres traducteurs.

Today we present to you what we consider to be a candidate for the release of Qt Creator 1.3.0.

In the month since we released the beta version, we were busy taking your feedback (thanks for that!) and transforming it into code . As a result of that many parts have seen improvements, for example there were issues with the Qt for Symbian support mended (e.g. support for S60 3rd Ed. FP1), several fixes for the refactoring engine done, and debugging improved.

This is a candidate, and we would like to hear of any issues you still find with it. We expect the final release before the end of the year, so now is the time to go to the public Qt Bug Tracker, and tell us.

You can download the packages from the Qt Creator Preview Website.

At the Munich DevDays we got a lot of questions about QML - first among them was where to download it. To celebrate DevDays in San Francisco we are releasing binary snapshots that you can download now for Windows, Mac and Linux.

For those of you who couldn’t attend DevDays, QML helps you create exciting UIs like this:

Remember - QML still isn’t released so it isn’t as solid as we’d like, but it should be enough for you to get started. The packages include a full version of Qt Creator - simply create a new QML project, let your creative juices flow and press play to view your creation in the QML viewer.

When Qt 4.6 is released, we’ll make another more up to date package. As we approach this milestone we’re focusing our attention on writing tests, squashing bugs, updating docs and giving the examples a little love - so by Qt 4.6 QML should be even better!

For those of you who don’t read the new Qt blog website, where Qt Marketing and Product Management talk about “corporatey” stuff (affectionately called the “PHB blog” by our developers), we’ve just announced that our brand, new bugtracker is public: see http://bugreports.qt.nokia.com.

So, I won’t repeat everything that is in the other blog (it is, after all, written by Marketing, so it should be better written than this thrown-together “reblogging”). I’d just like to highlight one important point that Adam made in his blog:

The Qt Bug Tracker isn´t simply a read-only view into the bug tracking system used by Qt developers, it is the bug tracking tracking system used by Qt developers.

The previous solution was an in-house system we had built over the years. It started as a distribution list for the Qt developers back in the day, then got an automatic tool to reply to the emails received and assign numbers, a robot to collect incoming emails and add to the database. Internally, we’ve had a rich-client to access that database and manipulate our own bugs. But communicating with the reporters was always very difficult.

This new tool is different. Everything is on the web. And you get to vote on issues, even watch if they change.

This is another step in our opening up of our development model. Enjoy!

Autumn has finally arrived, it can be clearly felt everywhere in Berlin. Less daylight, more clouds, longer nights - but to keep your mind on the bright things of life, I bring you the good news that we’ve released the beta preview of the upcoming next release of Qt Creator

If you have followed this blog, then you already heard of many of the upcoming changes and improvements. I want to mention some of greater impact here:

Renaming symbols, global and local, and finding usages of symbols. Local symbols are renamed inline while typing, for other symbols a list of changes is shown for review before doing any renaming.
Be sure to use the high quality button and make the video full screen when viewing it.

Experimental support for development of Qt applications targeting the Symbian platform. This means that building and running applications against a Symbian/S60 device should work in general, but that the whole experience is not what we expect from a polished product. Have a look at the respective part of the Qt Creator documentation for prerequisites and explanations.

Also:

• Completion of include directives
• Color schemes for the text editor
• Brace, parenthesis, bracket and quote matching
• Locator filter for symbols in current document “. typeyourlocalsymbolhere”
• Integrated jom for multicore compiling projects with MSVC tool chain
• Lots and lots and lots of improvements and fixes!

Check out a more complete list in the changes file.

Qt Creator 1.3.0 beta landing page.