Akademy 2015 Call For Papers Reminder

The call for papers for Akademy 2015 is on the 31st of March, which is scarcely over a week away.

If you want to talk at Akademy it is important to submit your application on time.

We have a large number of short and lightning talks available again this year, which is a fantastic opportunity to give everyone a brief overview of what’s been happening in your project over the past year. I would like to see every active project presenting something.

Don’t leave it too late and miss out.

Instructions on how to submit can be found at https://akademy.kde.org/2015/cfp.

Plasmoid Tutorial 3 – Blending In

Till now we have dealt with basic QtQuick Text items. Whilst they work, they will look out of place on a Plasma desktop. More importantly it’s quite likely that you can get a situation where you can get black text on a black background, or another unreadable combination.

If we run our current applet as soon as we change to another theme we get a problem.

We want to have consistent visual style amongst plasmoids that follows the user’s themes, along with consistent spacing throughout the shell. We want all “third party” plasmoids to follow these rules too.

We provide a set of imports that help make this happen.

The visual Plasma import come under 3 categories:


This contain low level shapes; such as varying frames, SVG loading and icons, as well as a utility to get DPI independent sizes to use for spacing and other metrics. Useful for keeping things consistent.


This contains the standard set of “widgets”; text boxes, spin boxes and labels and much more.


This is extra utilities that may be useful in your plasmoid.

Best Practices

  • Avoid hardcoding fonts and colours. Use the ones from the user’s theme.
    If you must hardcode, make sure you never hardcode on top of a theme background or parts could end up unreadable.
  • Avoid using the Text element from the QtQuick import, instead use Label from Plasma components, it will set the right fonts and sizes automatically.
  • Do not adjust font sizes and styles. For headings use the Plasma Heading element with the appropriate level set to affect font size.
  • Set all animations to Theme.ShortAnimation or Theme.LongAnimation as appropriate.
  • Don’t use QtQuick.Controls directly from inside the main plasmoid view

Continuing The RSS Viewer example

If we apply that to our current RSS viewer, our main view code should end up looking something like this:

import QtQuick 2.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents
import org.kde.plasma.extras 2.0 as PlasmaExtras

Item {
    PlasmaExtras.ScrollArea {
        anchors.fill: parent
        ListView {
            id: mainList
            focus: true
            boundsBehavior: Flickable.StopAtBounds

            model: RssModel {
                id: rssModel
                source: "http://planetkde.org/rss20.xml"

            delegate: PlasmaComponents.ListItem {
                PlasmaComponents.Label {
                    anchors.left: parent.left
                    anchors.right: parent.right
                    height: implicitHeight

                    elide: Text.ElideRight
                    text: model.title

                MouseArea {
                    anchors.fill: parent
                    onClicked: Qt.openUrlExternally(model.link)

    PlasmaComponents.BusyIndicator {
        anchors.centerIn: parent
        //whilst the model is loading, stay visible
        //we use opacity rather than visible to force an animation
        opacity: rssModel.loading ? 1: 0

        Behavior on opacity {
            PropertyAnimation {
                //this comes from PlasmaCore
                duration: units.shortDuration

I’ve added a busy indicator (a spinning wheel) whilst we’re fetching the RSS feed, just as a way to show how we use units.ShortAnimation

Finally, we end up with something like this: which looks good on all Plasma themes.

Plasmoid Tutorial 2 – Getting Data

Almost all applets need to interact with external data sources and actions.

This could be showing the current battery state, editing a file or in the case of our example monitoring and fetching an RSS feed.

Within Plasmoids we have a few different ways of getting data. Each have some advantages and disadvantages.

I’m going to loosely touch on them all, hopefully providing links to find out more information on a topic.

In-built javascript

QML is all powered by a javascript engine and as we’ve seen in the web world a lot is powerful with just javascript.

We have access to a full XMLHttpRequest object, which behaves exactly the same as making AJAX calls in any other web page.

    Component.onCompleted: {
        var request = new XMLHttpRequest();
        request.onreadystatechange = function() {
            if (request.readyState == XMLHttpRequest.DONE) {
                var reply = request.responseXML.documentElement
                //do the sort of thing that web developers normally do
        request.open("GET", "http://example.com/something");

It’s simple-ish, particularly if you are coming from a web developer world.

QML Plugins from C++

Sometimes we need to make our own modules if we want to access existing libraries, or do fast processing or interact with hardware.

QML integrates natively with C++ amazingly, every QObject in C++ appears as a javascript object. We can create new instances, all properties, signals and invokable methods or slots are visible to the JS engine as properties and methods.

as an example if I have a QObject with the structure

class MyObject: public QObject
    Q_PROPERTY(QString someProperty READ someProperty CONSTANT);
    QString someProperty() const;

qmlRegisterType("MyLibrary", 1, 0 "MyObject");

from QML I can access it as follows.

MyObject {
  id: source

Text {
  text: source.someProperty

More information on writing plugins can be seen here

As you can see C++ plugins give you maximum integration, anything is possible, including creating new graphical types, models, or enums or anything else you might need to use in QML.
Unfortunately distribution is harder as it needs parts to be compiled.

Note that Qt provide several QML modules a full list of imports can be found here.

Including an XMLListModel that converts an XML feed into a model that can be used QtQuick, which is ideal for our tutorial of making a simple RSS reader.


Dataengines were an abstraction layer for fetching and data and performing actions used in Plasma 4. They provide a lanaguage agnostic method of providing data to a Plasmoid.

Dataengines made sense when we needed to be agnostic between various lanaguages; now QML is here to stay for a long long time this requirement vanishes. Writing a QML Plugin has numerous advantages over dataengines as you remove away a very limiting abstraction layer. QML Plugins allow exporting new types and enums and overall requires a lot less boiler plate code than dataengines.

However, if a dataengine already exists it totally makes sense to re-use it rather than rewriting the code from scratch, they have been honed over years of fixes and many are quite good.

For our RSS case, their is an RSS dataengine backed by libsyndication which is way more powerful than everything here as it handles every type of feed.
Unfortuantely at the time of writing this is blocked on PIM releasing.

plasmaengineexplorer provides a way to browse dataengines and contents.

High DPI Progress

High DPI Revisited

A few weeks ago I talked about high DPI in KDE applications

Abridged Recap

  • By settings QT_DEVICE_PIXEL_RATIO=2 Qt will scale all painting to draw things twice the size
  • By default this will just scale all our images so it slightly defeats the point of buying a fancy new high resolution screen
  • Qt can try and be clever and draw high resolution icons and other images
  • This is liable to break stuff, so requires each and every app to opt-in


On Monday this week I was loaned a high resolution laptop, and set about trying to make sure everything works perfectly within the KDE world.
We can now set this environment variable from a configuration file, and a user interface is in review to allow the user to manually set their scaling factor.

I then set about trying to enable high resolution image support in various applications and trying to fix all that is broken.

This task is two-fold. The first is fixing any bugs that result in simply enabling the high resolution icons. Second is making sure applications that provide their own images, do so in a way that still look spot on when used on a high resolution monitor.

Progress Screenshots

Here is my screenshot just after installing Kubuntu CI on a high resolution laptop (3800×1800).

We can correct some parts by just boosting the font size, but that doesn’t solve the problems of small checkboxes, buttons and other hit areas. This isn’t just a superficial problem and it becomes a major usability problem especially as these screens become more widespread.

This second screenshot shows the result with the device pixel ratio set and a weeks worth of fixing in a range of apps. (click for full size)

The most obvious thing is that the sizes are bigger, but more importantly this is happening whilst all icons and scrollbars remain crystal clear at the native resolution for that screen.

A zoomed in section looks like this:

Current Status

Every Qt5 app can double up with no work at all, but to look right requires some effort.

For some applications supporting high DPI has been easy. It is a single one line in KWrite, and suddenly all icons look spot on with no regressions. For applications such as Dolphin which do a lot more graphical tasks, this has not been so trivial. There are a lot of images involved, and a lot of complicated code around caching these which conflicts with the high resolution support without some further work.

I am tracking progress on a Kanboard page. Naturally I can’t do every application, but I hope that by checking a few I can make sure all of our frameworks have full support making it easy for every other developer.

We also have a problem that Qt4 applications do not support device independent pixels. There are still many applications without a frameworks release even in the upcoming 15.04 applications release. Even in the next applications release in 15.08 August we are still unlikely to see a released PIM stack.
Is it a good idea to add an option into our UIs that improves some applications at the cost of consistency? It’s not an easy answer.