Skip to content

Welcome to Planet KDE

This is a feed aggregator that collects what the contributors to the KDE community are writing on their respective blogs, in different languages

Monday, 18 March 2024

Since the dawn of the times, the only way to implement any effect that has fancy user interface used to be in C++. It would be rather an understatement to say that the C++ API is difficult to use or get it right so there are no glitches. On the other hand, it would be really nice to be able to implement dashboard-like effects while not compromise on code simplicity and maintainability, especially given the rise of popularity of overview effects a few years ago, which indicated that there is demand for such effects.

In order solve that problem, we started looking for some options and the most obvious one was QtQuick. It’s a quite powerful framework and it’s already used extensively in Plasma. So, in Plasma 5.24, we introduced basic support for implementing kwin effects written in QML and even added a new overview effect. Unfortunately, if you wanted to implement a QtQuick-based effect yourself, you would still have to write a bit of C++ glue yourself. This is not great because effects that use C++ are a distribution nightmare. They can’t be just uploaded to the KDE Store and then installed by clicking “Get New Effects…”. Furthermore, libkwin is a fast moving target with lots of ABI and API incompatible changes in every release. That’s not good if you’re an effect developer because it means you will need to invest a bit of time after every plasma release to port the effects to the new APIs or at least rebuild the effects to resolve ABI incompatibilities.

This has been changed in Plasma 6.0.

In Plasma 6, we’ve had the opportunity to address that pesky problem of requiring some C++ code and also improve the declarative effect API after learning some lessons while working on the overview and other effects. So, enough of history and let’s jump to the good stuff, shall we? 🙂

Project Structure

Declarative effects require some particular project structure that we need to learn first before writing any code

└── package
├── contents
│   └── ui
│   └── main.qml
└── metadata.json

The package directory is a toplevel directory, it should contain two things: a metadata.json file and a contents directory. The metadata.json file contains information about the name of the effect, what API it uses, the author, etc.

{
"KPackageStructure": "KWin/Effect",
"KPlugin": {
"Authors": [
{
"Email": "user@example.com",
"Name": "Name"
}
],
"Category": "Appearance",
"Description": "Yo",
"EnabledByDefault": false,
"Id": "hello-world",
"License": "MIT",
"Name": "Hello World"
},
"X-KDE-Ordering": 60,
"X-Plasma-API": "declarativescript"
}

The contents directory contains the rest of QML code, config files, assets, etc. Keep in mind that ui/main.qml is a “magical” file, it acts as an entry point, every effect must have it.

In order to install the effect and make it visible in Desktop Effects settings, you will need to run the following command

kpackagetool6 --type KWin/Effect --install package/

This is quite a lot to memorize. That’s why kwin provides an example qtquick effect that you can grab, tweak some metadata and you’re good to go. You can find the example project at https://invent.kde.org/plasma/kwin/-/tree/master/examples/quick-effect?ref_type=heads. Note that the example project also contains a CMakeLists.txt file, which provides an alternative way to install the effect by the means of cmake, i.e. make install or cmake --install builddir.

Hello World

Let’s start with an effect that simply shows a hello world message on the screen:

import QtQuick
import org.kde.kwin

SceneEffect {
id: effect

delegate: Rectangle {
color: "blue"

Text {
anchors.centerIn: parent
color: "white"
text: "Hello world!"
}
}

ScreenEdgeHandler {
enabled: true
edge: ScreenEdgeHandler.TopEdge
onActivated: effect.visible = !effect.visible
}

ShortcutHandler {
name: "Toggle Hello World Effect"
text: "Toggle Hello World Effect"
sequence: "Meta+H"
onActivated: effect.visible = !effect.visible
}

PinchGestureHandler {
direction: PinchGestureHandler.Direction.Contracting
fingerCount: 3
onActivated: effect.visible = !effect.visible
}
}

import QtQuick is needed to use basic QtQuick components such as Rectangle. import org.kde.kwin imports kwin specific components.

The SceneEffect is a special type that every declarative effect must use. Its delegate property specifies the content for every screen. In this case, it’s a blue rectangle with a “Hello World!” label in the center.

The ShortcutHandler is a helper that’s used to register global shortcuts. ShortcutHandler.name is the key of the global shortcut, it’s going to be used to store the shortcut in the config and other similar purposes. ShortcutHandler.text is a human readable description of the global shortcut, it’s going to be visible in the Shortcuts settings.

The ScreenEdgeHandler allows to reserve a screen edge. When the pointer hits that screen edge, some code can be executed by listening to the activated signal.

The PinchGestureHandler and SwipeGestureHandler allow to execute some code when the user makes a pinch or a swipe gesture, respectively.

effect.visible = !effect.visible toggles the visibility of the effect. When effect.visible is true, the effect is active and visible on the screen; otherwise it’s hidden. You need to set effect.visible to true in order to show the effect.

If you press Meta+H or make a pinch gesture or move the pointer to the top screen edge, you’re going to see something like this

Note that there are no windows visible anymore, it is the responsibility of the effect to decide what should be displayed on the screen now.

Displaying Windows

Being able to display text is great, but it’s not useful. Usually, effects need to display some windows, so let’s display the active window

    delegate: Rectangle {
color: "blue"

WindowThumbnail {
anchors.centerIn: parent
client: Workspace.activeWindow
}
}

The change is quite simple. Instead of displaying a Text component, there’s a WindowThumbnail component now. The WindowThumbnail type is provided by the org.kde.kwin module. WindowThumbnail.client indicates what window the thumbnail item should display.

Input

Input processing contains no kwin specific APIs. TapHandler, MouseArea, Keys and other stuff available in QtQuick should just work. For example, let’s implement an effect that arranges windows in a grid and if somebody middle clicks a window, it will be closed

    delegate: Rectangle {
color: "pink"

GridView {
id: grid
anchors.fill: parent
cellWidth: 300
cellHeight: 300

model: WindowModel {}
delegate: WindowThumbnail {
client: model.window
width: grid.cellWidth
height: grid.cellHeight

TapHandler {
acceptedButtons: Qt.MiddleButton
onTapped: client.closeWindow()
}
}
}
}

The code looks pretty straightforward except maybe the model of the GridView. WindowModel is a helper provided by org.kde.kwin module that lists all the windows. It can be passed to various views, Repeater, and so on.

The result can be seen here

Delegates are Per Screen

One thing to keep in mind is that the delegates are instantiated per screen. For example,

    delegate: Rectangle {
color: "yellow"

Text {
anchors.centerIn: parent
color: "black"
text: SceneView.screen.name
}
}

When you activate the effect on a setup with several outputs, each output will be filled with yellow color and the output name in the center

Usually, the output is irrelevant, but if you need to know what output particular delegate is displayed on, you could use the SceneView.screen attached property.

Configuration

As your effect grows, you will probably face the need to provide an option or two. Let’s say that we want the background color in our hello world effect to be configurable. How do we achieve that? The first step, is to add a main.xml file in package/contents/config directory, i.e.

package/
├── contents
│   ├── config
│   │   └── main.xml
│   └── ui
│   └── main.qml
└── metadata.json

The main.xml file lists all options

<?xml version="1.0" encoding="UTF-8"?>
<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
<kcfgfile name=""/>
<group name="">
<entry name="BackgroundColor" type="Color">
<default>#ff00ff</default>
</entry>
</group>
</kcfg>

In our case, only one option is needed: BackgroundColor, which has Color type and #ff00ff default value. You can refer to the KConfigXT documentation to learn more what other entry types are supported.

The next step is to actually use the BackgroundColor option

    delegate: Rectangle {
color: effect.configuration.BackgroundColor

Text {
anchors.centerIn: parent
color: "white"
text: "Hello world!"
}
}

effect.configuration is a map object that contains all the options listed in the main.xml.

Now, if you toggle the hello world effect, you’re going to see

There are a few more thing left to do though. If you navigate to Desktop Effects settings, you’re not going a configure button next to the hello world effect

Besides providing a main.xml file, the effect also needs to provide a config.ui file containing a configuration ui

package/
├── contents
│   ├── config
│   │   └── main.xml
│   └── ui
│   ├── config.ui
│   └── main.qml
└── metadata.json

The config.ui file is a regular Qt Designer UI file. The only special thing about it is that the controls that represent options should have special name format: kcfg_ + OptionName. For example, kcfg_BackgroundColor

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QuickEffectConfig</class>
<widget class="QWidget" name="QuickEffectConfig">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>455</width>
<height>177</height>
</rect>
</property>
<layout class="QFormLayout" name="formLayout">
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Background color:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="KColorButton" name="kcfg_BackgroundColor">
<property name="flat">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>KColorButton</class>
<extends>QPushButton</extends>
<header>kcolorbutton.h</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>

The last final piece in order to expose the configuration ui is to add the following line in the metadata.json file

"X-KDE-ConfigModule": "kcm_kwin4_genericscripted"

With all of that, the effect is finally displayed as configurable in the system settings and the background color can be changed

Sharing Your Effect With Other People

The preferred method to distribute third party extensions is via the KDE Store. Both JS and QML effects can be uploaded to the same “KWin Effects” category.

Documentation and Other Useful Resources

Documentation is still something that needs a lot of work (and writing it is no fun 🙁 ). KWin scripting API documentation can be found here https://develop.kde.org/docs/plasma/kwin/api/.

Besides the link above, it’s worth having a look at the examples https://invent.kde.org/plasma/kwin/-/tree/master/examples?ref_type=heads in kwin git repository.

Window Heap

If you need to pack or arrange windows like how the overview effect does, you could use the WindowHeap component from org.kde.kwin.private.effects module. BUT you need to keep in mind that that helper is private and has no stable API yet, so use it on your own risk (or copy paste the relevant code in kwin). Eventually, the WindowHeap will be stabilized once we are confident about its API.

The WindowHeap source code can be found at https://invent.kde.org/plasma/kwin/-/tree/2a13a330404c8d8a95f6264512aa06b0a560f55b/src/plugins/private.

More Examples

If you need more examples, I suggest to have a look at the desktop cube effect in kdeplasma-addons. It’s implemented using the same QML effect API in kwin + QtQuick3D. The source code can be found at https://invent.kde.org/plasma/kdeplasma-addons/-/tree/master/kwin/effects/cube?ref_type=heads

Conclusion

I hope that some people find this quick introduction to QML-based effects in KWin useful. Despite being a couple years old, declarative effects can be still considered being in the infancy stage and there’s a lot of untapped potential in them yet. The QML effect API is not perfect, and that’s why we are interested in feedback from third party extension developers. If you have some questions or feedback, feel free to reach out us at https://webchat.kde.org/#/room/#kwin:kde.org. Happy hacking!

Since a brief tryst with Ubuntu Budgie Edition, I’ve dearly missed its Raven side-panel, a special panel on the side of the screen that can be opened and closed with a click. As someone who needs a clean, minimal desktop, the workflow is just too perfect — when you have two or three widgets that you use frequently, but not frequently enough that they warrant permanent homes on a main panel, just stuff them into a disappearing side-panel that can be called with a quick key-combination or by clicking on an icon; It’s a great way to keep things out of the way, but within reach, without having a permanently cluttered system tray that you might want to keep clear for things like email notifications.

A cropped screenshot of my plasma desktop showing a side-panel on the right side of the screen containing the clipboard history widget and the media player widget. On the bottom panel is the Scriptinator plugin, showing a tooltip the following title "Show Panel," and body text "Show the hidden right panel.
My side panel, and the widget that launches it.

There are some drawbacks; this workflow isn’t well supported on KDE Plasma, so it’s a bit of a faff to set up, and only a few widgets will display nicely on a wide side-panel. For instance, it would be a dream to have the KDE weather widget automatically take advantage of the horizontal space and display the information that would usually be in its dropdown, but what you get instead is a giant icon, for now at least. I use my side-panel for my clipboard history and the media player widget, both of which play nicely with a side-panel. Another niggle I have with it is that, as far as I know, there’s no way to disable activation of the panel when your mouse pointer makes contact with the screen edge. This is a mild to moderate inconvenience when you’re working with applications that have toolbars on the sides of the window, like design applications often do.

For me, personally, the drawbacks aren’t so severe as to put me off of the workflow.

Creating and configuring the panel #

First, you’ll need to create a panel. To do this, right click on an empty section of your desktop, and select “Add Panel > Empty Panel.” When the panel appears, right click it and select “Enter Edit Mode.” Set up your panel however you like, but you will need to set “Visibility” to “Auto Hide” and may want to give it a width of at least 400px or so.

The panel settings configuration window.

Setting up the script #

Now, if you wanted to show and hide your panel with a keyboard shortcut, you can set up a focus shortcut in the panel settings window and stop here. If, like me, you want to toggle your panel by clicking on an icon somewhere, we’re going to have to use a wee script, but don’t worry, it’s not as hard as it sounds and I’ll take you through it step by step.

Before we can put our script together, we’re going to need to know what the ID of our panel is. Open up KRunner with Alt+F2 or Alt+Space and run plasma-interactiveconsole. This will launch KDE’s Desktop Shell Scripting Console. In the console, type print(panelIds); and click “Execute.” Assuming you entered that in correctly, what you should see now in the output console beneath the text editor is a series of numbers — the ID numbers of our panels. Keep a note of these numbers.

The interactive console showing a series of panel IDs printed to the console.
Look at those IDs.

Clear the text editor and enter the following:

let panel = panelById(401);

panel.hiding === "autohide" ? panel.hiding = "windowsgobelow" : panel.hiding = "autohide";

This will check if our panel is set to auto-hide; if it is, the script will set the panel to “windows go below” mode, otherwise it will set the panel to auto-hide.

Now to make use of those panel ID numbers. Which number corresponds to your new side-panel? While I can’t be sure, chances are it’s the last number on the list as we’ve just made the new panel a moment ago. So in the script above, where I have entered 401, enter the last number in your ID list and click “Execute.” At this point, if the ID number is correct, your panel should appear; click “Execute” once more to hide it.

Setting up the Scriptinator widget #

Alright, we’ve got our script ready, so we just need one more thing in place: a button or icon that we can click on to show and hide the panel. Fortunately, we can use a widget called “Scriptinator” to provide just this. Right click on an empty area of your desktop or a panel, click “Add Widgets,” and “Get New Widgets.”

A cropped screenshot of the widgets panel with the "get new widgets" button at the top.
Let’s get that widget.

From here, find and install Scriptinator. Once installed, simply drag it where you’d like it to live, either on your desktop, or on a panel. Once you’ve done that, right click on the widget and choose “Configure Scriptinator.” Here, enter the path of the icon you’d like to use in “Custom icon full path;” I used /usr/share/icons/breeze-dark/actions/22/sidebar-expand-right-symbolic.svg. In “OnClick Script,” enter the following:

qdbus org.kde.plasmashell /PlasmaShell evaluateScript ''

and between those single-quote marks, paste in the full script we put together in the Desktop Shell Scripting Console, like this:

qdbus org.kde.plasmashell /PlasmaShell evaluateScript 'let panel = panelById(401);

panel.hiding === "autohide" ? panel.hiding = "windowsgobelow" : panel.hiding = "autohide";'
The Scriptinator configuration window.

Set up a tooltip if you like, hit apply, and test out your toggle button.

Success! #

If you’ve done everything correctly, you should see your side-panel appear when you click the widget and disappear when you click a second time. You may need to restart to see your icon applied to the widget; if you don’t want to wait, you can drop the file path into “OnClick icon full path” in your Scriptinator configuration.

Sunday, 17 March 2024

We have a release of Kile 2.9.95, also known as 3.0 beta 4! Earlier today, Michel Ludwig tagged the current Git master. This is the first beta release since October 2019. Beside the port to KDE Frameworks 6 and Qt 6, it provides a couple of new features and bug fixes.

New features

  • Port to KDE Frameworks 6 & Qt 6 (Port by Carl Schwan)
  • Enable high-dpi support
  • Provide option to hide menu bar (Patch by Daniel Fichtner, #372295)
  • Configurable global default setting for the LivePreview engines (Patch by Florian Zumkeller-Quast, #450332)
  • Remove offline copy of "LaTeX2e: An unofficial reference manual", use online version instead (Patch by myself, Christoph Grüninger, Issue #7)

Fixed bugs

  • Kile crashes on selecting "Browse" or "Zoom" for document preview (Patch by Carl Schwan, #465547, #476207, #467435, #452618, #429452)
  • Kile crashes when generating new document (Patch by Carl Schwan, #436837)
  • Ensure \end{env} is inserted in the right place even when the user uses tabs for indentation (Patch by Kishore Gopalakrishnan, #322654)
  • Avoid saving console commands in bash history (Patch by Alessio Bonfiglio, #391537, #453935)
  • Don't crash when deleting templates (#413506)
  • Avoid crashing when closing a document that is being parsed (#404164)

Thanks to all the contributors. They fixed bugs, wrote documentation, modernized the code, and in general took care of Kile.

Enjoy the latest Kile release!

Saturday, 16 March 2024

Hi all,

I am back with another update for adapting icons to the 24px grid and doing some larger edits. This week, I worked on 3 rows, which is great, and was able to hit just past the 50% mark, it seems 😀

Here is a video with the changes:

Transitous is a new community-driven routing service. Add your own city and help make it great.

Since last Dolphin version 23.08, I spent a lot of my time making sure the transition to KF6/Qt6 went smoothly for dolphin and its dependencies and plugins and thanks to many others contributions, in particular Alexander and Nicolas, this went well. The objective being no-one would notice despite much code has changed and this mostly worked out.

Changes

A few behaviors and default have changed.

Files and folders are now selected with a single-click and opened with a double-click. This will mainly affect Neon Users, since most distros already had this behavior default. You can select the single-click-open mode on the first page of systemsettings, as it concerns also Plasma, file/open dialog and other applications.

The extract here option in the menu now has the behavior of the old "extract here and detect subfolders". This makes the menu less heavy on text while making the action more accessible.

Service menus will need some adaptation unfortunately, you will need to Moving them to a new location. Usually mv ~/.local/share/kservices5/ServiceMenus/* ~/.local/share/kio/servicemenus. (Ensure to have destination directory created: mkdir -p ~/.local/share/kio/servicemenus) You can read the updated documentation.

The F10 shortcut now opens the menu, instead of creating a directory. That's an important change to improve accessibility by providing standard shortcuts. You can change it back if you want, and you can also use the the standard shortcut for this action Ctrl+Shift+N.

New features

The settings have been reorganized making it easier to find what you are looking for. The Interface section regroups setitings regarding the UI elements of dolphin, and the view those that influences how the main view will display your files and folders.

Shoutout to Dimosthenis Krallis for pulling it off, this wasn't an easy task especially for a not yet regular contributor.

Thanks to Carl, we got a very nice visual improvement to KDE application with breeze. I really enjoy the change to Dolphin. Looking back at dolphin in plasma5 makes it glaring.

A small new feature, I added, is you can now middle click on a file to open it in the second application associated with its type. Let's say you have an html file you normally open with your browser, but sometimes you want to edit it. Now instead of going to the open-with menu you can middle-click it. This works for scripts as well, opening them in your default editor instead of the second application assoctiated with their type.

This was inspired by the fact that folders benefit from middle-click activations to open new tabs. Making this behavior configurable might make sense, suggestions welcome, but this seems like a sensible default at least.

Felix, my fellow dolphin co-maintainer, did a bunch of ui-refinement, like the free space label in the status bar and some very nice accessibility improvements, including the F10 shorcut change that now triggers the app menu by default.

You can open now open containing folders for files in the Recent Files.

Bug fixed

Akseli Lahtinen made sure to Resort directory size count after refreshing.

And in total 32 were fixed between Dolphin 23.08.05 and Dolphin 24.02.0. 480098 441070 477897 479596 478724 476670 473999 478117 477607 477288 476742 172967 452587 475547 422998 423884 440366 474951 474999 393152 473775 473377 473513 420870 472912 468445 469354 462778 417930 464594 471999 47197

New code, new bugs

Unfortunately whenever you ship new code, you risk introducing new bugs, and even months of testing didn't iron them all.

One I think you could have spotted earlier, was that on X11, panels are hidden after minimizing Dolphin window. Thanks to Nicolas fella, this was swiftly fixed and will reach users in next Dolphin release. In the meantime, this is a good time to learn about the shortcuts for panels:

  • F9: toggle places panel
  • F11: toggle information panel

We now have a need process to build packages for Windows and Mac OS, Dolphin has not made the transition though. I am working on it to bring latest dolphin to its Window and MacOS users.

Getting the KDE Mega Relase 6 out was a key milestone in the transition to Qt 6 and KDE Frameworks 6, but it doesn’t mean we are done yet. There’s still components to port and scaffolding to remove.

Porting remaining applications

While KDE Frameworks and Plasma switched completly to Qt 6 with the release, there’s still a number of components in KDE Gear using Qt 5 by default. The following modules still need work:

  • Artikulate
  • Cantor (MR)
  • Kalzium - has Qt6 CI already
  • Kig
  • KmPlot - has Qt6 CI already
  • KTouch (MR)
  • Marble (branch)
  • Minuet - has Qt6 CI already
  • Rocs (QtScript porting MR)
  • Step - has Qt6 CI already
  • KolourPaint (MR)
  • K3b - has Qt6 CI already
  • KMix
  • Kwave
  • Cervisia - partially ported
  • Lokalize (MR)
  • poxml
  • Umbrello
  • KDevelop (MR)
  • KRDC - has Qt6 CI already
  • KImageMap Editor - has partial Qt6 CI already
  • Kamoso
  • Kirigami Gallery (branch)
  • Calindori - CI is Qt6 only but default build is still Qt5?
  • ghostwriter - has Qt6 CI already

This list doesn’t include modules that are basically ported but cannot switch yet due to other things depending on them, ie. there is more than those not released for KF6 yet. Same goes for modules providing plugins that are still needed for both versions.

The complexity of the remaining work here ranges from putting on finishing touches and taking the decision to make the switch all the way to dealing with potentially difficult to port dependencies such as QtScript. So there’s something for everyone here ;)

And then there’s of course even more outside of the KDE Gear release automation that also needs to be looked at, Krita for example recently posted their plans for the migration to Qt 6.

Cleaning up porting aids

But even in the modules released exclusively for Qt6 and KF6 already there is still work to be done, namely removing the remaining uses of porting aids such as Qt5Compat.

While the need for this might not seem that pressing anymore there’s many good reasons for doing this sooner rather than later:

  • We have many people around still familiar with how to do that and its potential pitfalls. That knowledge tends to fade away over time.
  • We pay extra in download, storage and runtime cost for carrying around those dependencies. That matters especially for bundled apps, e.g. for some of our APKs this lead to a 20% size reduction.
  • Future-us will hate us for not doing this, in the same way as we were unhappy about past-us not having cleaned up after themselves during the 4 -> 5 migration.

QtCore5Compat

On the C++ side that’s basically QRegExp, QTextCodec and the SAX XML parsing API.

QTextCodec:

  • Uses for small chunks of UTF-8, Latin-1 or local 8 bit encoded strings can be replaced by QString API (not that common).
  • Use for larger amounts of data or different codecs can be replaced by QStringEncoder and QStringDecoder (the most common case).
  • Uses for listing all codecs needs new API in Qt 6.7 and cannot be replaced just yet (rare).
  • Uses in combination of QTextStream for non-Unicode content have no replacement (fortunately very rare by now).

QRegExp:

  • Fully replaceable by QRegularExpression.
  • Wildcard and exact match support might need changes to the actual expressions, either manually or via corresponding QRegularExpression helper methods (somewhat common by now as most easy case have long been converted).

Things get a bit more tricky for both of those when these types are used in API and thus propagate through larger parts of the code, but fortunately we only have a few of those cases left. The vast majority of uses is very localized.

SAX XML parser:

  • Replaceable by QXmlStreamReader.
  • Can require larger code changes and needs extra care when dealing with XML namespaces.
  • Fortunately rare by now.

Qt5Comapt.GraphicalEffects QML module

The other big part of Qt5Compat are about 25 graphical effects for QML.

  • DropShadow and RectangularGlow can in many cases be replaced by Kirigami.ShadowedRectangle, which is probably the most common case here. MultiEffect covers the rest, ie. shadows on anything else than (rounded) rectangles.
  • LinearGradient in any other orientation than vertical needs a nested and rotated `Rectangle` now to hold the gradient, see e.g. Kirigami.EdgeShadow for an example in horizontal or vertical orientation can be replaced by a Rectangle with associated Gradient (few cases left).
  • For anything else you have to hope that the Qt6 MultiEffect provides a suitable replacement. For the most common cases (blur and opacity masks) that’s the case fortunately, for more exotic effects you might need to get creative.

Plasma5Support

Qt5Compat isn’t the only porting aid though. Plasma5Support is another one to look at, with still hundreds of uses left just within KDE code.

Plasma5Support contains some of the former Plasma Framework functionality, such as the data engines. I have no experience porting away from that myself though, maybe the Plasma team can provide some guidance for that :)

You can help!

In particular removing the remaining porting aid uses in many cases doesn’t need in-depth knowledge of the affected applications but consists of separate and localized changes, so it’s the ideal side-task while waiting for longer compile runs for example.

LXR is a very useful tool for finding the remaining uses and the KDE Development channel on Matrix is the place to ask if you need help. Among my merge requests from the past two weeks you’ll also find 30+ examples for such changes.

In addition to lots and lots of Plasma 6 stability work and the beginning of Plasma 6.1 feature work, Dolphin received large amount of development this week, resulting in some nice improvements. Check it out!

New Features

KSSHAskPass (which has the best name of any app in the world, change my mind) now supports SK-type SSH keys (Franz Baumgärtner, KSSHAskPass 24.05. Link)

Gave the Web Browser widget the option to always load a specific page every time, or remember the last-browsed-to one (Shubham Arora, Plasma 6.1. Link):

Info Center has a new page showing you technical audio information for debugging purposes (Shubham Arora, Plasma 6.1. Link)

The icon chooser dialog now has a filter so you can see only symbolic icons, or no symbolic icons (Kai Uwe Broulik, Frameworks 6.1. Link):

UI Improvements

Dolphin’s icon once again changes with the accent color (Kai Uwe Broulik, Dolphin 24.02.1. Link)

Most of Dolphin’s bars now animate appearing and disappearing (Felix Ernst, Dolphin 24.05. Link):

Some folders in Dolphin get special view settings applied by default, such as the Trash and Recent Files/Folders locations. Now these special view settings get applied to those folders even if you’re using the “use same view settings for all folders” setting (Jin Liu, Dolphin 24.05. Link)

Dolphin now has a new tab in its settings window for settings about its panels, which were previously hidden away in a context menu. So far just the Information Panel is represented there, but others may be added later! (Benedikt Thiemer, Dolphin 24.05. Link):

Made touch scrolling in Konsole work better (Willian Wang, Konsole 24.05. Link)

Improved the way Konsole’s text cursor scales on Wayland, especially with fractional scale factors (Luis Javier Merino Morán, Konsole 24.05. Link)

Okular already lets you scroll around a document with the hjkl keys. Now if you hold down the Shift key while doing it, it scrolls 10 times faster! (Someone going by the pseudonym “GI GI”, Okular 24.05. Link)

KRunner-powered search fields in Overview and the Search widget show the same search ordering that other ones already do (Alexander Lohnau, Plasma 6.0.2. Link)

The Power and Energy widget now hides its “Show Battery percentage on icon when not fully charged” option when the system has no batteries (Natalie Clarius, Plasma 6.0.2. Link)

With non-random wallpaper slideshows, Plasma now remembers the last-seen one and starts from there the next time you log in (Fushan Wen, Plasma 6.0.2. Link)

Improved keyboard navigation in Kirigami sidebars powered by the GlobalDrawer component (Carl Schwan, Frameworks 6.1. Link)

Increased the size of the “Get new Plasma Widgets” dialog (Me: Nate Graham, Frameworks 6.1. Link)

Bug Fixes

Fixed one source of issues with the lock screen breaking on X11 by showing a black background. There may be more, and we’re on the case for those too (Jakob Petsovits, Plasma 6.0.2. Link)

Fixed a way that the Battery Monitor widget could cause Plasma to crash (Natalie Clarius, Plasma 6.0.2. Link)

Fixed a way that Plasma could crash when you middle-click tasks in the Task Manager, or rapidly left-click on random audio-playing tasks (Fushan Wen, Plasma 6.0.2, Link 1 and link 2)

On X11, clicks no longer get eaten on part of top panels (Yifan Zhu, Plasma 6.0.2. Link)

On X11, lock and sleep inhibitions once again work (Jakub Gocoł, Plasma 6.0.2. Link)

Fixed most of the incorrectly-colored System Tray icons when using mixed dark/light themes. There’s still one remaining source of this that we found, which is also being worked on (Nicolas Fella, Plasma 6.0.2. Link)

You can once again scrub through songs played in Spotify using the Media Player widget (Fushan Wen, Plasma 6.0.2. Link)

Fixed several issues with panel widgets (including Kickoff) incorrectly passing focus to their parent panel when activated (Niccolò Venerandi, Plasma 6.0.2. Link)

Dragging widgets to or from panels no longer sometimes causes Plasma to crash or makes the widget get stuck in ghost form on the desktop (Marco Martin, Plasma 6.0.3. Link 1 and link 2)

On Wayland, adding a second keyboard layout now causes the relevant System Tray widget to appear immediately, rather than only after Plasma or the system was restarted (Harald Sitter, Plasma 6.0.3. Link)

Fixed a way that Bluetooth pairing could fail (Ajrat Makhmutov, Plasma 6.0.3, Link)

On X11, the screen chooser OSD works again (Fushan Wen, Plasma 6.0.3. Link)

Breeze GTK is once again the default GTK theme (Fabian Vogt, Plasma 6.0.3. Link)

Yet again fixed the login sound so that it actually plays (Harald Sitter, Plasma 6.0.3. Link)

Reverted to an older and better way of sending pointer events on Wayland, which fixes multiple issues involving windows and cursors teleporting unexpectedly while dragging to maximize or de-maximize windows (Vlad Zahorodnii, Plasma 6.1. Link 1, link 2, and link 3)

Fixed a bunch of weird cursor issues with GPUs that don’t support variable refresh rate properly (Xaver Hugl, Plasma 6.1. Link)

Fixed a source of xdg-desktop-portal crashes on boot (David Redondo, Frameworks 6.1 Link)

Fixed two issues with the “Get New [thing]” dialogs that caused them to not show installation progress correctly, and get stuck after uninstalling something (Akseli Lahtinen, Frameworks 6.1. Link 1 and link 2)

System Monitor charts now appear properly for users of 10+ year-old Intel integrated GPUs (Arjen Hiemstra, Frameworks 6.1. Link)

More UI elements throughout QtQuick-based KDE software stop animating when animations are globally disabled, which also fixes an issue where Plasma button highlights would disappear with animations are globally disabled (me: Nate Graham, Frameworks 6.1. Link 1 and link 2)

Other bug information of note:

Performance & Technical

Fixed a source of 25-second Plasma startup delays when using KDE Connect with Bluetooth disabled or absent (Simon Redman, the next KDE Connect release, though most distros have already backported it. Link)

Fixed another source of slow Plasma startups caused by using the Bing picture of the day wallpaper (Fushan Wen, Plasma 6.0.2. Link)

KWin now does direct scan-out even for rotated screens (Xaver Hugl, Plasma 6.1. Link)

Reduced the size of all the wallpapers in the plasma-workspace-wallpapers repo by 10 MB (Martin Rys, Plasma 6.1. Link)

Ported Kile to KDE Frameworks 6. Hopefully this should presage a new release soon (Carl Schwan, link)

Automation & Systematization

Wrote a tutorial about setting up your app’s continuous integration system to package and publish to the Windows store (Ingo Klöcker, link)

Added some autotests for X11-specific window behavior (Vlad Zahorodnii, link)

Other

Rewrote a some chunks of text on KDE neon’s website to make it reflect reality: it is a distro, its target users are those who want KDE stuff fast and can tolerate some instability, and you shouldn’t use the package manager to get apps (me: Nate Graham, link 1, link 2, link 3, and link 4)

…And Everything Else

This blog only covers the tip of the iceberg! If you’re hungry for more, check out https://planet.kde.org, where you can find more news from other KDE contributors.

How You Can Help

Please help with bug triage! The Bugzilla volumes are extraordinary right now and we are overwhelmed. I’ll be doing another blog post on this tomorrow; for now, if you’re interested, read this.

Otherwise, visit https://community.kde.org/Get_Involved to discover other ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

As a final reminder, 99.9% of KDE runs on labor that KDE e.V. didn’t pay for. If you’d like to help change that, consider donating today!

Friday, 15 March 2024

Let’s go for my web review for the week 2024-11.


The Getty Makes Nearly 88,000 Art Images Free to Use However You Like | Open Culture

Tags: foss, culture, art

This is a big and relevant release for open and freely accessible culture.

https://www.openculture.com/2024/03/the-getty-makes-nearly-88000-art-images-free-to-use-however-you-like.html


Announcing Speedometer 3.0: A Shared Browser Benchmark for Web Application Responsiveness

Tags: tech, browser, frontend, web, performance, benchmarking

This is nice to see a new benchmark being published. This seems to follow real life scenarios. We can expect browser engines performance to increase.

https://browserbench.org/announcements/speedometer3/


Rebuilding FourSquare for ActivityPub using OpenStreetMap – Terence Eden’s Blog

Tags: tech, fediverse, map, geospatial

Neat early experiments on query OSM for nearest potential point of interests and of geolocation support in ActivityPub implementations.

https://shkspr.mobi/blog/2024/01/rebuilding-foursquare-for-activitypub-using-openstreetmap/


S3 is files, but not a filesystem

Tags: tech, cloud, storage, amazon

A good explanation of the S3 pros and cons.

https://calpaterson.com/s3.html


Not so quickly extending QUIC

Tags: tech, networking, protocols, standard, quic

Interesting stuff coming in that space, but at a very slow pace. This is unfortunate since it makes adoption slower too.

https://lwn.net/Articles/964377/


Cloning a laptop over NVME TCP

Tags: tech, storage, networking

Very interesting trick! I didn’t know you could use NVME over TCP. This is indeed perfect for cloning a laptop. This sounds slow but this is the kind of things you can run over night.

https://copyninja.in/blog/clone_laptop_nvmet.html


How HEAD works in git

Tags: tech, tools, git, version-control

Good explanations on how HEAD works in git and what it means. It’s indeed one of those terms where the consistency isn’t great in git.

https://jvns.ca/blog/2024/03/08/how-head-works-in-git/


A TUI Git client inspired by Magit

Tags: tech, git, command-line

Looks like an interesting Git user interface. I’ll take it out for a spin.

https://github.com/altsem/gitu


C++ safety, in context – Sutter’s Mill

Tags: tech, c++, memory, safety

Excellent piece from Herb Sutter once again. This is a very well balanced view about language safety and how far C++ could go in this direction. This is a nice call to action, would like to see quite some of that happen.

https://herbsutter.com/2024/03/11/safety-in-context/


A Tale of Two Standards

Tags: tech, standard, portability, unix, linux, posix, windows, history

An old article, but a fascinating read. This gives a good account on the evolution of POSIX and Win32. The differences in design and approaches are covered. Very much recommended.

https://www.samba.org/samba/news/articles/low_point/tale_two_stds_os2.html


Screen Space Reflection

Tags: tech, 3d, shader

Interesting walk through of a shader to compute reflections in a scene.

https://zznewclear13.github.io/posts/screen-space-reflection-en/


My favourite animation trick: exponential smoothing | lisyarus blog

Tags: tech, graphics, animation

A deep dive in the properties of exponential smoothing for animations. It’s often overlooked.

https://lisyarus.github.io/blog/programming/2023/02/21/exponential-smoothing.html


cohost! - “Rotation with three shears”

Tags: tech, graphics, history

Fascinating trick in 2d graphics. Not really useful nowadays, but interesting.

https://cohost.org/tomforsyth/post/891823-rotation-with-three


What Mob Programming is Bad At • Buttondown

Tags: tech, optimization, pairing, mob-programming

Interesting take and theory about pair and mob programming. Indeed finding the right path to optimize a piece of code is likely harder in such setups.

https://buttondown.email/hillelwayne/archive/what-mob-programming-is-bad-at/


40 years of programming

Tags: tech, craftsmanship, career

Very interesting insights from someone who’s been practicing this trade for a long time. I agree with most of it, it’s inspiring.

https://liw.fi/40/


On The Importance of Getting The Foundations Right - Cybernetist

Tags: tech, engineering, craftsmanship, architecture

Definitely this. The difference between a well performing team and one delivering subpar software is the basics of our trade. Minding your data models, your architectures and the engineering practices will get you a long way.

https://cybernetist.com/2024/03/11/importance-of-getting-the-foundations-right/


Work on tasks, not stories | nicole@web

Tags: tech, project-management, agile

Definitely this. The distinction between stories and tasks is an important one. Don’t confuse them.

https://ntietz.com/blog/work-on-tasks-not-stories/


Breaking Down Tasks - Jacob Kaplan-Moss

Tags: tech, project-management, estimates

This is indeed an important aspect of estimating work. The smaller you manage to break down tasks the easier it will be to estimate. Breaking down work is a skill in itself though.

https://jacobian.org/2024/mar/11/breaking-down-tasks/


Futility of Shortening Iterations | by Aviv Ben-Yosef | Mar, 2024 | Medium

Tags: tech, product-management, project-management

There’s some truth to this. Shorter optimized iterations with no good learning opportunities lead to busy work.

https://avivby.medium.com/futility-of-shortening-iterations-af4d3a3d9b3d


So you’ve been reorg’d… - Jacob Kaplan-Moss

Tags: management, organization

A bit US centric at times, but there are some more generally applicable advices in this piece. This can help you navigate in the time of a company reorganization (not always called out as such).

https://jacobian.org/2024/mar/12/reorg/



Bye for now!

Qt 6.7 introduces convenience improvements for implementing typical RESTful/HTTP client applications. The goal was/is to reduce the repeating networking boilerplate code by up to 40% by addressing the small but systematically repeating needs in a more convenient way. 

These include a new QHttpHeaders class for representing HTTP headers, QNetworkRequestFactory for creating API-specific requests,  QRestAccessManager class for addressing small but often-repeating pieces of code, and QRestReply class for extracting the data from replies and checking for errors. QNetworkRequestFactory, QRestAccessManager, and QRestReply are released as Technical Previews in Qt 6.7.