Tag Archives: Qt

Declarative Knowledge Base


As I described in the latest entry, with the KDE Plasma Workspace 4.6 there will be a new feature that will be a key one for the future evolution of the Plasma platform: the ability to write plasmoids with just QML and Javascript.

So, let’s try to see if it’s possible rewrite the average widget in with the declarative scriptengine…

We have a dataengine (using a neat library called Attica) that can query the various functionalities of websites that offer an API compatible with the Open Collaboration Services, such as OpenDesktop.org. One of the features offered by this API is the Knowledge Base: users subscribed to the site can ask any question (in topic with the website) and other users can answer to them. Plasma offers a desktop widget that can query and visualize those question/answers. It’s written in c++ and is about 400-500 lines of code.

How much QML code would take to write a very minimal Declarative Plasmoid that can access the knowledge base entries trough the Plasma dataengine? Here it is

import Qt 4.7
import org.kde.plasma.core 0.1 as PlasmaCore

ListView {
    clip: true
    width: 200
    height: 300

    PlasmaCore.DataSource {
        id: source
        engine: "ocs"
        source: "KnowledgeBaseList\provider:https://api.opendesktop.org/v1/\query:opendesktop\sortMode:new\page:0\pageSize:10"
        interval: 120000

    model: PlasmaCore.DataModel {
        dataSource: source
        key: "KnowledgeBase-[\d]*"

    delegate: Text {
        text: Name

24 lines πŸ˜‰

What is important to look here is the DataSource{} definition that defines to what engine we’re connecting and to what source. And the DataModel{} that hooks up what has been fetched by the DataSource to a suitable model for the use by the ListView.

Let’s expand from this to something that can be compared to the C++ version in terms of functionality. You can download an early example of the code from here. (all is available from the playground svn repo). It’s still early to include it in the 4.6 release for various reasons, but the path is definitely clear πŸ™‚

Here you can see a brief screencast of the two plasmoids, the C++ and the declarative one working side by side.

OGG version

Here is a video tutorial that explains the steps taken to write this plasmoid.

It is also a little demo of the Plasmate IDE that while it’s still at early development stages, it’s pretty impressive already: all you have to do is write the code and test it in the preview side panel. zero worries about creating the package structure, desktop files or installing :p

OGG version

Netbook and performance


Probably I should had written this little notice uhm, a quite while :), anyways, it’s quite technical but here there are a little hint on how to make the Netbook shell a garzillion times faster, if you’re hit by an unfortunate series of circumstances that makes it run sloooowly πŸ™‚

Why on some netbooks it runs slow

As shown here, The Plasma Netbook shell can be quite fast on a standard netbook, however many are experiencing it going rather slow. Why?

Qt can use different graphics backends to render the graphics, now on X11 systems the default is the one that is called surprisingly enough, X11, that relies heavily on XLib and XRender. Now, this sounds allgreat, but two things tends to happen.

If the Xrender acceleration of the video drivers is pretty poor, things tend to slow down.

Second, if QPainter hits some code patch that aren’t directly implemented via the X11 graphics system it will have to fall back to another paint system: raster, that is totally software based, so pixmap-to-image conversion (and memory copy) is involved (and is necessary, to not actually lose features depending on what graphics system you’re on), and things slow down.

Now, with Intel drivers things seem to not go soo well, especially for items clipping: that’s unfortunately what’s used more heavily in Plasma Netbook πŸ™‚ the newspaper and the search and launch result works as follows: a smaller QGraphicsWidget contains a bigger one, that contains the actual contents that could be the plasmoids of the newspaper for instance. the outer widget has a particular flag that enables clipping, so what overflows from the parent widget won’t be actually drawn.

with Intel drivers and the X11 graphics system this seems to be pretty fast until the parent widget is of a certain size, then performance degrades significantly pretty quickly.

The actual how to

So the alternative is to use the raster graphicssystem from the start, that is really fast (especially if one think about that is completely software based rendering) there are basically 3 ways to do it:

the application can be invoked with the graphicssystem commanline switch, so:

plasma-netbook -graphicssystem raster

But this has to be done every time, or Qt can be configured at build time to use this as default (some distributions such as Gentoo or MeeGo actually do this) but will have the effect on every Qt application.

So I’ve added a config file option in Plasma Netbook to use it as default even if Qt has X11 as default: with Plasma Netbook not running, edit the file

~/.kde/share/config/plasma-netbookrc (in some distributions could be ~/.kde4 instead)

And add the following line:


That’s it πŸ™‚

Here is a video that compares before and after on the usual EeePC 1005ha, with a bright note: the difference isn’t anymore so noticeable like it was used to some months ago, even tough it’s still makes the difference.

OGG version

Why isn’t the default?

Two reasons: it’s still quite unstable sometimes, overall with X11 Plasma (and other Kde apps as well) seems to (still) be more stable.

But most importat, as said it’s purely software based, so it could be not so gentle on the CPU (so with the battery life). I mean, it’s impressive how much it’s efficient, but will never belike a working gpu based solution. So if you aren’t running on the problem described before, it’s probably better you keep it as is.

So there is hope for the future?

Absolutely! a still experimental new graphics system is in the works, using this time OpenGL. The whole application (any Qt one actually) can be run completely with OpenGl drawing with the -graphicssystem opengl, or just a QGraphicsView can use it (by using a QGLWidget as viewport). That’s exactly what happens if you start Plasma Netbook with

plasma-netbook --opengl

This works in the new born Plasma Mobile too by the way. and is a great hope especially in those two sheels, since GPUs of small devices are designed to be not soo fast, but to be very low power, a bit less than the cpu, actually.

Right now, as in KDE SC 4.5 and Qt 4.6/4.7 is still not for everyday use, is still not so stable and there are some graphical glithces (this actually varies from a graphics driver/video card model like crazy) but what is encouraging is that since this feature was introduced (Qt 4.4) it came a very long way, it’s really sooo better than when it was originally out.

Multitouch screencast overload


Going a bit more deeply on how KDE SC 4.4 will support multitouch, here are 3 longer videos:

The first one shows marble. Is now possible (with the usual disclaimer on devices and systems that support it, hoping it will become a more pervasive feature) to zoom the earth with a two fingers gesture, making a retty natural interacion

OGG version

The second one shows Plasma: it’s possible to move, resize and rotate the widgets with two fingers, making them a bit more “real objects”. Another place of Plasma that supports multitouch is the “Blackboard” widget (painting with two fingers simultaneously ftv) and all the animated scroll widgets, such as the one used in the microblogging plasmoid and in the netbook and the webkit based widget.

OGG version

The last one shows in detail the Webbrowser widget, in particular two fingers scrolling (note that is still possible to select text with a single finger, while scrolling with two) and pinch zoom with two fingers again, all correctly maped to any transformation the widget can have.

OGG version

Cuteness 4.6


Qt 4.6 has been released yay!

A while ago i received from Nokia a cute Dell Latitude Xt2 multitouch tablet pc, to produce some demos of a really really nice new feature of Qt 4.6: multitouch.

Qt provides two ways to acessing multitouch: one more abstract, where the type of gesture and direction of fingers movement already “parsed” so you already know if the user wants to zoom, scroll or rotate, that’s QGesture that’s useful to control for instance scrolling and zooming in a web browser.

If you want instead something more raw, the position of every finger now and on the last sampling, you have instead QTouchEvent. That’s useful if you want for instace paint with multiple fingers on a paint program or want implement some weird type of gesture not provided as stock. oh, and no It’s a rather different (and more simple) concept compared to Multi pointer X, since is a single event with multiple positions, rather than multiple simultaneous events.

So I tought that in KDE we have soe things that would make as an impressive demo with multitouch, so why not give it a try with Marble and Plasma :). So that’s the result (thanks to the trolls for the final edit):

This OGG version, unfortunately this is only a “raw” version, without music and titles, but gives the idea

It will be supported in KDE 4.4. Th only catch is that right now X11 doesn’t support it (..yet:p), so just as a tech demo will be possible to try it on the windows and mac builds of KDE

Multitouch, a preview


Since I saw Plasma for the first time, I immediately imagined it as something really organic, where you can manipulate the objects on the canvas like one would do with real objects, just grab them with one or two hands and move them, rotate them, stretch them to make them fit as you like.

Now Qt 4.6 among a ton of new features has really qute multitouch capabilities, and made this possible, here is a sneak peek:

Won’t say more for now, more on that later :p

I did the first part of the video, than the trolls put some pepper into it (love the epic music :p)

New job


A new quite interesting chapter of my life is started since quite some time, I didn’t want to say too much about it until everything was settled down and up to speed. But now i guess the time has come, let me introduce my new employer, a pretty familiar and constant presence in the KDE development:

Qt development frameworks

Thanks to the generous support of those people, these days known as Qt Development Frameworks (and the mother company Nokia of course), I’ll be sponsored to work full time on KDE, in particular on the Plasma libraries and shells, especially the Plasma netbook project, that is taking up shape quite nicely. Plus there will be another quite cool Qt-related project

I will remain based here in Italy, but especially starting from next year perhaps it would be more probable to see me wandering around conferences around the world, we’ll see πŸ™‚

What i can say: Qt Development Frameworks (or: our little old dear trolls) rocks!