Context

If you are already familiar with the structure of Qt 5 code, feel free to jump to the next section.

In Qt 4, the whole source code is in the same git repository. The traditional widgets derived from QWidget are part of the QtGui module and represent a central piece for the GUI application development.

In Qt 5, things changed. Qt code were splitted in many repositories which group Qt libraries depending on their functionalities.
Examples of repositories are qtbase, qtdeclarative, qtjsbackend, qtxmlpatterns, qtsvg, qttools, etc.
As you may know, QtQuick 2 became a first class citizen in Qt 5, which means qtdeclarative is one of the main repositories, house of QtQuick and QtQml classes.

But, there are classes that provide the base for QtQuick 2 work properly – they are part of the qtbase repo. There you find QtCore,
QtGui, QtNetwork, QtOpenGL, QtPlatformSupport, QtXml, QtWidgets, etc.

Wait: What’s the difference between QtGui and QtWidgets?

As part of the changes of Qt 5, QtGui is now focused in the basic infrastructure for GUI work on different platforms. For example, it is the place for the platform abstraction layer, window management, image handling, etc.

QtWidgets, as you can conclude based on its name, contains the children of QWidget: QPushButton, QSpinBox, QMainWindow, etc. Also, there are non-widgets classes in QtWidgets, some of them because they are internally too coupled to QWidget classes.

Origins

In this thread it was mentioned the case of QUndoStack, QUndoCommand that are in QtWidgets but can be useful in other contexts where developers do not want to link against QtWidgets just because of this kind of helper classes.
Later, in the change 15857 (with the help of ogoffart), we discussed about moving QUndo* out of QtWidgets. First, we moved these classes to QtGui what as not considered correct given the new motivation of this lib. Then, another idea was to move the classes to a new lib, inside qtbase. It was not considered ideal and the decision was to create a separated repo for these classes, leaving QtWidgets untouched (since the Qt community do not want to introduce new bugs in this lib).

Current status

We set a wiki page where it is possible to check the classes made available out of QtWidgets. Also, there are instructions about where to download the source code, build, test and contact us.

Besides moving classes out of QtWidgets, some prototypes of convenience APIs were created for QtQuick 2 developers and we are very interested in receiving feedback about them. It’s worth mentioning the QML API for UndoStack and the CompletionModel which is based on the internals of QCompleter and was made available in a QML friendly way.

The following example shows a possible use case for the CompletionModel. Improving the models supported by sourceModel is part of the ToDo list. The ListView is going to show the updated list that currently satisfies what is written in the TextInput.

TextInput {
    id: input
}

CompletionModel {
    id: completionModel
    sourceModel: ["Ascension Island", "Andorra", "Afghanistan"]
    completionPrefix: input.text
    caseSensitivity: Qt.CaseInsensitive
}

ListView {
    model: completionModel
    delegate: Text { text: modelData }
}

The two examples bellow show the UndoStack and two items that represent commands. The idea of UndoPropertyCommand is to enable track the changes of some properties. In the example, we are going to track x and y when myRect is moved.

UndoStack {
    id: stack
    undoLimit: 5
}

UndoPropertyCommand {
    id: moveCommand
    properties: ["x", "y"]
}

Rectangle {
    id: myRect

    (...)

    MouseArea {
        (...)
        drag.target: parent
        onPressed: stack.push(moveCommand, myRect);
    }
}

UndoCommand is another element used to represent commands. The difference here is that it allows the customization of the actions onUndo and onRedo the command.

UndoCommand {
    id: aCommand

    onUndo: doAThing(target);
    onRedo: undoAThing(target);
}

Button {
    onClicked: stack.push(aCommand, target);
}

Future

Maybe one day this playground project gets promoted and become a Qt Add-on, but there is no expectation it will happen before 5.0. In the meanwhile, there is a ToDo list with some topics we consider important to handle, like better examples, more tests, docs, etc.

We are looking forward receiving more opinions about this work and, as always, contributors are welcome!

Then, after the end of this project, I finally managed to contribute to Qt5! :-)

Also, in the end of the last year some coworkers started a kind of pet project: It’s called Iceberg, a fork of the Icecream Monitor.

“Why a fork?” Here we use icecream for distributed compilation, many colleagues used to complain about icemon depending on kdelibs. In fact, the code did not use the additional features compared to the equivalent Qt classes. Then, after hugopl started the project, we fixed some issues and added new stuff. The code is here.

I am writing another post to introduce one of our current research projects, which is also part of the proposal I sent to Akademy 2012.

To ease this process, I wrote a small script that does almost the same described in Lizardo’s post, with some new pseudo features. It needs some improvements, the known ones are marked with #XXX – contributions are welcome!

It consists in 2 files, the script and a config file where the user can customize the directories where things will be installed, the directory of the downloaded files, the version of S60 that will be used. Initially it’s ready for S60 3rd edition FP2 and S60 5th edition (Check here the version of your target device), etc.

Running the script, the first step shows the URLs to files you have to download, but need login or other kind of interaction with the website. The script is a nice guy, when it’s possible “he” asks if you allow him to open those URLs in your default browser =)

The script then downloads other files that are direct accessible and the installation begins. If everything goes right, in the end your environment will be ready for Qt-S60 development.

Wanna try? Download a it here or git clone it:

git clone git://littlechina.org/anselmo/setupQtS60env

That’s it =)

ToDo:

• Simplify updates of Qt-S60 in a environment already in use.
• Solve the #XXX in the script
• Probably there are other things that I don’t remember now =)
• UPDATE: 2009-10-17: There are some issues in qmake when using DEPLOYMENT
• UPDATE2: 2009-10-19: The old daily builds aren’t available anymore, a message there says that they “back tonight hopefully”
• UPDATE3: 2009-10-20: Builds are back =)
• UPDATE4: 2009-11-01: The gnupoc patch for Qt-S60 needs to be uptaded =/ .
• Hopefully it’s going to save us =) http://labs.trolltech.com/blogs/2009/10/28/a-new-symbian-toolchain-for-linux/

As I said in my previous post, we discussed about new good examples that could show use cases of this new API. In the end, only one example was created, but it’s really cool =) .

Maybe some of you will recognize this interface, it looks like canola2‘s main menu, another software developed by INdT for Nokia internet tablets (e.g. N810) – and as you can read here, an old bug was fixed and canola2 is now a free software, released under GPLv3. In this post you can read more about the development of that interface.

So, we wrote an example based on that concept. During the development we had nice discussions regarding the algorithm for the engine that controls the icons distribution on the screen.

Check it out:

http://www.youtube.com/watch?v=eJcTBJaPRZg

http://www.youtube.com/watch?v=eJcTBJaPRZg

The source code is not available yet, but it will be published soon in a git repository near you, then you will be able to check how animated layouts were used and also see that algorithm I’ve just mentined. So, stay tuned!

A quick introduction:  in the end of February I posted a video showing the first example of layouts animations.  At that time, the API wasn’t complete and there was no integration with states and some stuff were hardcoded.

In March some Trolls visited Recife to speak at Bossa Conference 2009 (you can watch the presentations on http://openbossa.blip.tv). It was nice because we could talk about the work we’re doing together using whiteboards, what makes a huge difference =) .

After Bossa, we continued the development of the Animated Layouts API, making layout proxies transparent and integrating with the Qt State Machine Framework. It now allows the customization of animations per widget, bringing more flexibility in the creation of rich user interfaces using Qt.

The following video shows the old example with these improvements:

http://www.youtube.com/watch?v=wZo1wskBs0A

link: http://www.youtube.com/watch?v=wZo1wskBs0A

After that, we created some examples in order to show use cases and also to test what had been developed, but it is the next post’s subject! (remember what I said in the beginning? ;) )

We are working together with Qt Software guys in the Qt Kinetic project, specifically with animated layout transitions.

Last week we made our first demo of what is being developed. It uses the basics we’ve just finished, now we’re working to define the final API. The following video shows this demo:

http://www.youtube.com/watch?v=M3HbmrNvQl4

video link: http://www.youtube.com/watch?v=M3HbmrNvQl4

Interested? Read this overview and more details about internals written by co-workers, then join us at #qt-kinetic @ Freenode =)

PS: <portuguese>Há também uma visão geral em português a respeito neste post. </portuguese>