Legacy system tray icons back in Plasma 5

Didn’t we drop support?

Legacy system tray icons are problematic; they don’t scale, they don’t fit in with the theme, they can’t multiplex (be in two trays) and they’re just generally very dated.

We came up with a new scheme Status Notifier Items (SNIs) back in 2009, which was also adopted by our friends at Ubuntu in Unity, which provides logical information over DBus about what to show, rather than just an arbitrary window.

Our existing xembed code needed an entire rewrite, given wayland would also break xembed it seemed a more useful investment of time to make sure most the toolkits supported the SNI specification than work on the rewrite.

In retrospect, I think we underestimated the fallout this would cause. There are propreitory apps, more random toolkits that weren’t covered, and some distros didn’t apply all the patches needed

There’s nothing wrong with changing our minds in response to user feedback.

Restored Support

Having decided that we can’t drop support just yet, it seems unlikely we can drop it in a few months when we switch to Wayland. So we need to consider how to make that work there. Embedding an X window inside a wayland window isn’t going to work.

My solution was a hidden process, xembedsniproxy, renders the embedded windows offscreen then uses the existing SNI specification to inform Plasma. Plasma gets support, including multiplexing without really knowing about X.

It should be as seemless as anything else.

Current State

It’s at a state where it’s usable, but there are undoubtedly still some bugs. Every toolkit has their own quirks regarding system trays.

Please leave a comment if you find anything.

The code is currently in a test repository here

It is available already in yaourt for Arch users:
aur/xembed-sni-proxy-git

I hope to have it merged into Plasma for 5.5, depending on feedback.

Just another manic monday

I love project stats, and I completely obsess over bug reports.
Whilst collecting data for another post, a mystery libreoffice autocomplete popup me to plot something I hadn’t thought of plotting.

What days of the week are bugs opened and closed?


Resolved can mean one of a few things; fixing the bug with a change in the code, marking it as a duplicate of another bug or in some cases closing it as not a direction we want to go with Plasma.

Observations

People report more on weekdays than weekends

The difference surprised me. I think it gives a strong indication that Plasma 5 is being used more for work than as a hobby, with people more likely to encounter an area needing to improvement during the normal office week.

Obviously we don’t know for sure and we can’t pull useful timestamp information without knowing timezone of the user, but indications seem to be there.

Bugs are resolved on a weeked at 50% of the rate of the weekday

This isn’t too surprising given that some Plasma maintainers like myself work for Blue Systems or Red Hat and we tend to work office hours.

What’s encouraging is that, whilst slower, this shows that a significant amount of work does happen outside office hours; both employees taking the extra time to care for Plasma and our community contributors stepping up to work here. There’s some shift between the people doing weekday and weekend bug closing.

We get more bugs open than we close

Naturally our graph will show that we have some open bugs, but if we assume this rate continues our number of open bugs will continue to rise.

It’s not as bad as this graph makes it look as there also a lot of bugs in a zombie “needs info” state, where we’re waiting to hear back from a user either with more information or to confirm their issue is fixed.

We definitely need more help here, I want Plasma to be bug free.

It’s all about Tuesdays

Tuesday is apparently the day for the most reports getting handled. It’s also the day Plasma 5.4 gets released.

I always knew Tuesday was an underrated day of the week.

Powered By Swiss Cheese – My Plans For Randa

At the start of September I’m going to be taking a vacation from Blue Systems work; ignoring all things Plasma and spend an entire week to spend some time on some other projects.

This will be the second time I’ll be attending Randa. Last year was simulatenously one of the most hard-working enduring sprints possible yet also one of the most enjoyable weeks in close proximity to some of my best friends.

This year I intend to devote all my time working with the KDE Connect team.

As there is so much cross-project work, it’s a lot easier when I can talk to the right people, making Randa the right opportunity.

Some of my project plans during that week – KDE Connect

Smaller Connections?

Android Wear is becoming more than a gimmick. What should KDE Connect integrate? Should we make the media player remote work? Desktop notifications? Blood Pressure monitor as you read certain email threads… certainly some potential.

Desktop to Desktop

The main thing KDE Connect works is where you are in close proximity to your phone and desktop, but don’t want to keep physically switching between everything. For most normal people, a phone and a desktop is enough…but some of us have two machines that we have to switch between and most the same principles of mouse sharing, notifications(?) and files applies.

Most of the relevant code exists; it just needs that final bit of UI on top.

KDE Connect for SMS Messaging in KTp

I ported all the wonderful work by Alexandr Akulich to Qt5 with the KDE connect refactoring, and it’s all merged, bitrotting slowly, it just needs that final push of work to get it out the door.

Fundraising

I’m one of many many who will be at Randa working on a huge range of interesting projects.

We need money in order for sprints like Randa to go ahead; it costs money to get everyone under the same roof, and the organisation at Randa is done in a way that keeps everyone productive.

Whilst I’m lucky enough to fund my own flights, me from yesteryear would have struggled, and we are all giving up our time to work on KDE. We also need support to help get everyone doing great stuff there.

Please donate to the fundraiser using the giant link below



High DPI in Plasma 5.4

As retrofitting high DPI support into such a large range of both KDE and third party applications is risky to do without breakage, progress is deliberately slow and gradual in order to do this right.

The good news is I get to write lots of blog posts as we make the continual steps forwards.

Iterative Progress

Plasma 5.3 (last release)

* High DPI Scaling via a hidden config option for early testing

Plasma 5.4 (this release)

* User facing dialog with the screen management settings for scaling

Plasma 5.5+ (future releases)

* Automtatically enabled. Providing we see positive feedback in this release.

The New Setting

Plasma 5.4 brings a new setting to adjust the screen scaling to match your device.

In the new setting we’ve tried to simplify things to a simple slider which adjusts both font size which we have full control over, and then above a certain threshold adjusting the entire UI which we can only do at integer values (i.e doubling the size). This is to support the semi-high screens and the current generation all in the same place.

It’s still far from what I’d like to achieve overall, but it does the job of making some devices usable.

What Can We Expect From This Release?

With High DPI support enabled you will see one of three things amongst your applications:

  • The app sized sensibly, looking absolutely gorgeous on your new screen.
  • The app sized sensibly, but some aspects may not necessarily make the full use of the higher resolutions available.
  • The app not scaled at all remaining really small. We should see the font size increase to fit, but icons, dialogs, checkboxes may remain annoyingly small.

We’ve tried to make sure the most common, important KDE applications (Dolphin, Konsole, Kate and so on) fit into that top category. An app like xfig or dia, will remain in the bottom category until Wayland.

There’s also a slim chance there may also be some breakage.
If so please do file a bug report as soon as possible and tag me to the CC list.

Props especially go to Christoph Cullman and Alex Fiestas for their help on some of the applications.

Last month in Plasma

We’re nearly a third of our way into the Plasma 5.4 cycle, most of the developers seem to be shy so I wanted to give a summary of just some of the activity.

The focus

With Plasma 5 now hitting major distributions by default our biggest focus is bug fixing. We get roughly 10 new bugs every day, each of which have to triaged, and if appropriate fixed. Somehow we’re managing to stay on top of things.

KCM Rewrites

System Settings is one of the older parts of the Plasma stack

Antonis and Marco have been working on porting some of the modules to use QML with QtQuickControls.

This poses an interesting challenge; QtQuickControls are definitely the future of not only Plasma but for all KDE applications, however, in their current state they are problematic. The desktop theme has various quirks, as it tries to interact with the classic QStyle and we don’t benfit from the same huge sets of KDE libraries that were written for widgets.

We need to find a balance between modernising, progressing with new technology, but also never hampering the user experience for the sake “progress”.

For now these are merged in a development branch of plasma-desktop, KcmQmlPorts. I’d encourage people to check it out and report and fix issues there.

Extra Plasmoid Changes

Bernhard Friedreich has been restoring all the functionality in the timer applet that wasn’t prioritised in the initial rewrite from Plasma 4. It now is in a far better state than it has ever been.

The task manager gained a feature from Yoann Laissus to allow launching a new instance of an application by middle clicking. Hopefully speeding up some people’s workflow.

Wonko Sane ported the Konsole quick launch applet too Plasma 5 allowing users to quickly start various different konsole sessions right from their desktop.

We’re also seeing a lot happen in the “3rd party” world on kde-look. There are now 2 pages worth of additional applets that people are making. Worth checking out.

Helping out

We’ve had a lot of new faces in Plasma
We’ve been updating our build instructions, which walks through building all of frameworks on Plasma into a new directory, in simple instructions that work perfectly on all non-Debian based distributions.

Hidden – copy this to the dot

Plasma Sprint 2015

In February 2015 the Plasma developers met in the Blue Systems office in Barcelona to discuss and plan out where we would take Plasma over the duration of the next year. The sprint consisted of active Plasma develoeprs and visual designers from around the world; from Canada to India.

The meeting consisted of equal parts hacking and group discussions about plans both in the near and far future in breakout sessions throughout the week.

Hacking

Improved Developer Tools

One of the important parts of Plasma is making it as easy for others to contribute as possible. Marco worked on a tool making it easy for designers to explore, edit, create and assess the completeness of Plasma themes. Sebastian introduced “Cuttlefish”, a tool for designers and application developers to examine the current icon set of a system. It can be used to display the icons available on the system, and how they are presented at various sizes. Both of these should make it into the next release of Plasmate.

Enhanced Power Management

Good power management has always been a fundamental part of the Plasma experience, during the sprint we experimented with restoring kinfocenter to life to be a useful central hub of advanced information. This allows us to provide all sorts of extra information without cluttering the main desktop. This will make it possible to visually identify where your battery life is going.

In addition, several tweaks were made to the battery notifications and timeouts.

Plasma Media Center

Plasmashell was modified to allow it to boot directly into media center mode, allowing it to be launched directly from the login screen.

Design work

During the hacking time, designers Jens and Ken began producing and designing additional promotional material for our upcoming marketing needs. This included updated logos, vectorised Konquis, and other assets.

Planning For The Future

Much of the sprint was spent planning out future goals, a new framework for sharing actions and invoking actions across applications, called KPurpose which we should hear more of in upcoming releases. We discussed the future of notifications for not only current instant notifications but calendar based alerts.

Work and initial prototyping went into unifying application header space and making use of window decoration space in applications.

Hopefully over the next years of Plasma we will see these features come to life in future release release announcements. Exciting times lie ahead.

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:

org.kde.plasma.core

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.

org.kde.plasma.components

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

org.kde.plasma.extras

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");
        request.send();
    }

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);
    Q_OBJECT
public:
    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

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.