Planet KDE

Subscribe to Planet KDE feed Planet KDE
Planet KDE | English
Updated: 59 min 7 sec ago

Plasma 5.25 Beta

Wed, 2022-05-18 20:00

Today we are bringing you the preview version of KDE’s Plasma 5.25 desktop release. Plasma 5.25 Beta is aimed at testers, developers, and bug-hunters.

To help KDE developers iron out bugs and solve issues, install Plasma 5.25 Beta and test run the features listed below. Please report bugs to our bug tracker.

We will be holding a Plasma 5.25 beta review day on May 26 (details will be published on our social media) and you can join us for a day of bug-hunting, triaging and solving alongside the Plasma devs!

The final version of Plasma 5.25 will become available for the general public on the 14th of June.

DISCLAIMER: This release contains untested and unstable software. It is highly recommended you do not use this version in a production environment and do not use it as your daily work environment. You risk crashes and loss of data.

See below the most noteworthy changes that need testing:

Breeze Plasma Workspace Plasma Desktop KWin Discover Plasma Addons Info Center Other

Other things to look out for are glitches both in the X11 and Wayland versions of Plasma, incomplete or incorrect translations, and anything that behaves incorrectly but used to work in prior versions of Plasma.

Remember to check and see if your bug has already been reported before reporting a new one.

View full changelog
Categories: FLOSS Project Planets

Maui 2.1.2 Release

Mon, 2022-05-16 12:32

We are pleased to announce a new stable release of MauiKit Frameworks and Maui Apps 2.1.2!

Stable release

This version of Maui brings new features and bug fixes to Maui’s applications and the frameworks they rely on. The changes introduced in this release will make your experience with Maui Apps much more enjoyable and feature-rich across different devices and form factors.

Read on to find out how Maui’s software has improved and what new features to look out for:


If you are interested in using the Maui Apps, there are different ways you can do so:

MauiKit Frameworks and Maui Apps are packaged by different distros, like Arch, and derived distros, such as Manjaro; KDE Neon on unstable repositories, postmarketOS, and Nitrux OS.

Nitrux OS includes the Maui Apps by default and Manjaro with Plasma Mobile. So you can wait a few days for the distributions to update the packages for you.

For using Maui Apps on Android, we provide APK packages. The links to the packages will be listed here and on the Maui official webpage under each app section.

There is an active task to start publishing the apps to the platforms’ respective stores; you can follow up on the progress:​

AppImage packages are also available for AMD64 and ARM, so you can also grab one of them, also linked in this blog post.

Remember to open a ticket at Invent if you find bugs, issues, or have a feature request.


To get the TARs, APKs, and AppImages you can go directly to each app page under or go to

MauiKit Framework 2.1.2

MauiKit is a group of frameworks used to build Maui applications. It comes with standard widgets crafted to work well on small phone screens and larger desktop computer monitors. But that’s not all: MauiKit also has utilities that help developers build applications more quickly with more complex and ready-made widgets. These include a text editor, an image viewer, or a file explorer.

In this updated version, the graphical components have been polished. New widgets have been added to the MauiKit Core library, making navigation easier on phones, desktop computers, and other devices.

Before continuing, just a quick reminder: you can check the previous Maui Reports leading up to this new stable release at:

Maui Report 18 MauiKit

We improved the code of MauiKit. Solving bugs with better performance optimizations. We added a few new controls; this is what’s new:

  • FontsComboBox is a new control for listing and quickly previewing fonts.
  • Apps use Maui Style by default. MauiKit must be built with the -DBUNDLE_MAUI_STYLE=OFF flag to use the system style. Using Maui Style the apps will have a better and more consistent look; and faster startup times since it is precompiled.
  • New StackView control, with smooth transitions.
  • Adaptive color schemes and custom accent colors.
  • The AnimatedImage control can now play animated AVIF images.
  • Fixes to the FlexItem control used in the SettingsSection in settings dialogs.
  • MauiModel now allows having multiple filtering terms.
  • Fixes to the MauiModel filtering.
FileBrowsing, TextEditor, ImageTools & Accounts
  • Minor fixes here and there.
Maui Style
  • Styling fixes to the ScrollBar, ContextualMenu, and Popup controls.
Maui Apps 2.1.2

The Maui Project provides a set of applications to cover the essential utilities. The Maui line of apps currently includes a file manager (Index), a music player (Vvave), an image viewer (Pix), a text editor (Nota), an app for note-taking (Buho), a terminal emulator (Station), an app to manage your contacts (Communicator), a document viewer (Shelf), a video player (Clip), a camera app (Booth), and a web browser (Sol).



  • Preview support for animated AVIF images.
  • New optional Action Toolbar with everyday actions as buttons.
  • Menu entries moved to the browser menu.
  • Uses the new MauiKit StackView for smoother transitions between views.
  • More information is in the file contextual menu header.
  • Now multiple filters can be applied in the search, separated by a comma; for example: “pdf, screen, avif” will show results for any files matching those terms.



  • The Tracks view now lists the most played tracks and recent playlists on the header for quick access.
  • The focus view can now be set as the default view, making Vvave faster to start since the collection views are not being loaded.
  • The focus views now ship with a search field for quick queries, which the user can trigger with Ctrl+K.
  • The focus view is now using the adaptive color scheme based on the current track artwork.
  • Vvave now uses the new MauiKit StackView for smoother transitions between views.
  • Fixed bug causing the go-to artist/album to fail before the app loaded those views.
  • Apps can now apply multiple terms to filter the collection in the search boxes.


  • We moved the slimmer toolbar and the previous options to the Add tool button.
  • Now uses the new Mauikit FontsComboBox control to preview the available fonts in the settings dialog quickly.
  • Uses the new MauiKit StackView for smoother transitions between views.


  • Initial work on intelligent tags.
  • Fixes to the geolocation tags.
  • Faster to launch when invoked with an external image. Now the app can pass modules, and for example, the viewer can be the default view, the tags or folders, etc.
  • It can now be used to open folder directories and list all the images.
  • Preview animated images on hover at the gallery views.
  • Tweaks to the folder’s view, showing header information of the current folder being viewed.
  • Users can trigger the keyboard shortcut for selecting all images with Ctrl+A.
  • The dark mode is now used by default on the image viewer.
  • Uses the new MauiKit StackView for smoother transitions between views.
  • Added a new option go-to folder, which shows all images in the same source folder.
  • Users can now apply multiple terms to filter the collection in the search boxes.


  • Now uses the new Mauikit FontsComboBox control to preview the available fonts in the settings dialog quickly.
  • Uses the new MauiKit StackView for smoother transitions between views.


  • Faster startup by going directly into the player view without loading the collection view when invoked externally with an URL.
  • Slimmer toolbars.
  • Fixes to the optional MPV backend for audio, subtitles, and corrections.
  • The dark mode is now used by default on the player viewer.
  • Uses the new MauiKit StackView for smoother transitions between views.


  • Multi-tab support for opening multiple documents.
  • Shelf Poppler plugin fixes document sizes and faster loading. Benefiting, for example, Index’s PDF previews.
  • Uses the new MauiKit StackView for smoother transitions between views.
  • Multiple terms can now be applied to filter the collection in the search boxes.


  • Fix bugs.
  • Now uses the new Mauikit FontsComboBox control to quickly preview the available fonts in the settings dialog.



  • Polished the delegates.


To follow the Maui Project’s development or say hi, you can join us on Telegram:

We are present on Twitter and Mastodon:

Release date 2021 2022 2023 February 1.2.1 2.1.1 2.2.2 May 1.2.2 2.1.2 3.0.0 August 2.0.0 2.2.0 3.1.0 November 2.1.0 2.2.1 3.1.1

A quick reminder of the project’s immediate future goals:

  • Fully utilize CMake. [Done]
    • Developers can build apps and the framework with CMake for all targeted platforms.
  • More feature-rich applications. [In Progress]
    • Pix image editor and GPS location browsing.
    • VVave’s metadata editor and cloud streaming.
    • Index – feature-rich file management.
    • Better integration with Android. Idle states and background playback.
  • Improve data synchronization using NextCloud. [Pending]
    • Only Buho and Vvave have initial support.
    • For 2.1, We will add support for Pix as well. [Pending]
  • Improve performance. [In progress]
    • We have split the MauiKit framework into different components.
    • MauiKit::Core controls are faster and more coherent.
    • 5X faster startup times for Maui Apps
  • Improve the UI cohesion on all supported platforms. [In Progress]
    • Maui Style has been improved constantly.
  • Move beta apps to stable. [In Progress]
    • Shelf and Clip have been moved to stable, missing the Sol, Booth, Strike, and Bonsai.
    • NX SC has been moved to Nitrux org.

The post Maui 2.1.2 Release appeared first on MauiKit — #UIFramework.

Categories: FLOSS Project Planets

KDE Goals Process

Mon, 2022-05-16 06:20


Sorry everyone, it has been a while. Of course, the lack of updates to my blog doesn’t mean that the KDE Goals were also not progressing. On the contrary! Wayland, Consistency and Apps are looking better than ever before.

Today, I don’t want to talk about the Goals themselves, but rather about the process of selecting new Goals.

You see, Akademy 2022 has been recently announced. And because we have a date of the event, it means we can take a look at the process that is described on the community wiki and determine when the new Goals can be created.

The process says, that 15 weeks before the start of Akademy the submission stage begins. Since this year’s Akademy is held October 1-7, looking at my calendar it means that June 17th should be the start date. That’s soon! But don’t worry, that stage lasts 4 weeks, so if you’d like to submit a new Goal for the KDE community, you still have time to think about it.

After the submission stage, a refinement stage and voting follow. Check the wiki page for details.

I’d like to use the remaining time before mid-June to talk about what makes a good KDE Goal, summarize the current ones, and interview with our Champions about tips for those that would like to take their place. Check the blog for updates on all of that!

Categories: FLOSS Project Planets

MeeraNew font new release 1.3

Mon, 2022-05-16 05:43

MeeraNew is the default Malayalam font for Fedora 36. I have just released a much improved version of this libre font and they are just built for Fedora 36 & rawhide; which should reach the users in a week of time. For the impatient, you may enable updates-testing repository and provide karma/feedback.

Fig. 1: MeeraNew definitive-script Malayalam font version 1.3.

Two major improvements are present in version 1.3

  1. Improved x-height to match RIT Rachana, the serif counterpart. This should improve readability at default font sizes.
  2. Large improvements to many kerning pairs including the above-base mark positioning of dotreph (0D4E) character (e.g. ൎയ്യ), ി (0D3F), ീ (0D40) vowel symbols (e.g. ന്റി), post-base symbols of Ya, Va (e.g. സ്ത്യ) etc.

The font source and OTF/TTF files can be downloaded at Rachana website or at GitLab.

Categories: FLOSS Project Planets

Daily Buggle

Sun, 2022-05-15 18:00

For FreeBSD things, there are four bug lists I keep track of; those are the “important bits” for me. It’s my bugs, and CMake bugs, and desktop bugs, and KDE bugs. Four lists, and sort-of-easy to query from FreeBSD’s bugzilla. I sometimes post to the socials a “daily buggle” of the counts of those lists. That started as a spoof of Wordle posts (I prefer Worldle myself) but has now grown to a tool of its own.

Here are the four bug lists I care about:

  • My bugs, which is bugs I have filed or been assigned. Stuff that is important for me personally.
  • CMake bugs, which are bugs that mention CMake. These may be CMake bugs, or may be ports-that-need-CMake attention.
  • Desktop bugs, bugs assigned to the desktop@ team. This might be desktop-basic infrastructure, or might be GNOME things because there’s no dedicated GNOME team.
  • KDE bugs, bugs for the KDE team. This includes CMake, Qt, KDE Frameworks, KDE Plasma and KDE Gear.

There is some overlap between the lists: CMake bugs are often on the KDE list as well.

Each of these bug lists can be read in CSV mode, leading to a format of one-line-of-headers and then a single line per bug. So for obtaining bug counts, I could use curl, then pipe to wc -l and subtract 1. Or Python. Or, who knows, awk and kio-fuse to read the web query as a file into awk. There anre many possibilities, so I arbitrarily chose Rust to implement a tool to do the fetching for me.

I’ve been intending to learn a little Rust for some time. Not particularly for production use, but as a what-is-this-about project it’s fine. It’s been a long time since I picked up a new programming language and I notice that something like Rust by Example just pisses me off. Along that path lie terrible copy-paste programs, and since I wrote way too much unwrap() in this program, I suspect I’m Doing It Wrong as well.

Buggle is my little project for doing Bugzilla queries (for FreeBSD anyway) and then Twitting about it. It’s also my project for learning some Rust. Probably it should grow something more Free Software friendly, like Matrix-posting, instead.

I’m not sure that Buggle is usable for anyone else: it needs tokens (both for the application and for user access) which I have stored locally.

I’m not sure that Buggle is usable for anyone else: it feels like largely glue code, written over four days of pointedly-not-reading-enough-documentation, (about the language) and feeling frustrated by the documentation that there is (for the libraries). At this point I certainly Have Opinions (and a 1.9GB build directory). I’ll be returning to Rust some other time. In the meantime, Buggle will be tweeing about my C++ bug-counts.

Categories: FLOSS Project Planets

The KDE Qt5 Patch Collection has been rebased on top of Qt 5.15.4

Sat, 2022-05-14 06:17



Commercial release announcement: 

OpenSource release announcement:


I want to personally extend my gratitude to the Commercial users of Qt for beta testing Qt 5.15.4 for the rest of us.


The Commercial Qt 5.15.4 release introduced some bugs that have later been fixed. Thanks to that, our Patchset Collection has been able to incorporate the reverts for those two bugs that affected Android and Windows and the Free Software users will never be affected by those!

Categories: FLOSS Project Planets

Building Plasma for KDE Frameworks 6

Sat, 2022-05-14 03:45

Time for another KDE Frameworks 6 update! Since the last one we made significant progress on getting Plasma to build, which also clears the way for properly styled and platform integrated Qt6-based applications.

KDE Frameworks

Since about a month ago the second to last Framework is also building with Qt 6 and has CI coverage for that. This was plasma-framework, which enabled a lot of progress in the Plasma modules build on top.


There’s also plenty of changes going into applications to prepare for the transition to 6. This is usually done in the same fashion as for Frameworks and Plasma, alongside the 5 code without compromising that, to identify potential issues/risks/challenges as early as possible.

For some applications like Kate this has meanwhile even progressed to a somewhat working state, as described in a post by the Kate team.


Of the 51 Plasma repositories relevant for Plasma 6, 29 have already CI coverage for 6, another 10 are building but depend on still pending changes or other modules not available in the CI yet. For a more detailed overview, see this tracking task.

For the rest of the Plasma modules it’s mostly down to the following remaining issues:

  • Use of the removed QDesktopWidget, in particular creative uses such as workarounds for old problems that need careful case by case assessment and occasionally some archaeology.
  • Other removed API in Qt 6 or KF6 without a straightforward replacement. This can be seemingly simple cases like the QNetworkAccessManager::NotAccessible enum, or more complex things like KServiceTypeTrader.
  • A few remaining cases of low-level OpenGL or event handling code in KWin.

If you want to help, here’s a quick summary on how to build with Qt 6 again, given you are familiar with building with Qt 5.

The main difference is the need for the following additional CMake arguments:


This might seem a bit redundant and unnecessarily cumbersome, and indeed not all of those arguments are needed by all modules. But it’s easier to just use the superset everywhere. And of course all of that will go away once we switch to 6 exclusively.

If you are using kdesrc-build, that also provides configurations for several modules sets already. Those not only contain the necessary build options, but also list the modules that are expected to build already. Include kf6-qt6-build-include instead of kf5-qt5-build-include to use those.

Both approaches assume you do have Qt 6, from distribution packages or self-compiled, and you point CMake to that if it’s not in the default search location.

Also for both cases, a few words of caution:

  • This is only meant to support the transition to 6, and is only aimed at people actively working on this. It is still far away from being practically usable.
  • Co-installability isn’t available yet, in parts this uses the same names and install locations as a 5 installation. Put it into a separate prefix.
  • Interference from Qt-based dependencies that don’t support multiple major Qt versions yet has to be expected, this often shows in form of build errors due to mixing Qt 5 and Qt 6. You might need to comment out the corresponding find_package() calls locally for now.
  • Being able to build does not imply being able to run. This is especially true for QML based code at this point.

That’s not meant to scare you away, just to manage expectations :) If you want to help, give it a try!

Google Open Source Peer Bonus

Our ongoing Frameworks 6 effort got nominated for the Google Open Source Peer Bonus award, alongside the work of many other FOSS contributors.

For some reason this has my name next to it despite being a big team effort. Anyway, I took care of the involved paperwork and made sure the price money has been transferred to KDE e.V..


To participate, here are the most important coordination and communication channels:

Categories: FLOSS Project Planets

This week in KDE: something for everyone

Sat, 2022-05-14 00:46

This week we have a little bit of everything! Hopefully everyone should be able to find something to like:

15-Minute Bugs Resolved

Current number of bugs: 68, down from 70. 0 added and 2 resolved:

When Discover’s window is narrow/mobile mode and you search for something, the search field now disappears as expected when you resize the window to be wider (Matej Starc, Plasma 5.24.6)

System Settings’ sidebar view now remains visually in sync when the page shown by the main panel is changed by something else, such as opening a different page from KRunner (Nicolas Fella, Plasma 5.24.6)

Current list of bugs

New Features

Elisa is now able to display lyrics embedded in files that are using the LRC format, and automatically scroll the lyrics view as the song plays! (Han Young, Elisa 22.08)

There is now a user-facing option to control Tablet Mode! It retains its current default value of “switch automatically when relevant” which is only available on Wayland, but you can now additionally force it to be always on always off, and those options work on X11 too! (Marco Martin, Plasma 5.25):

System Monitor now has an option to make a page start loading data as soon as the app is opened–rather than as soon as the page is accessed–and the default History page now uses it by default (Arjen Hiemstra, Plasma 5.25)

Bugfixes & Performance Improvements

Yakuake no longer inappropriately opens on the active screen when configured to always open on a specific screen (Jonathan F., Yakuake 22.04.1)

When using Gwenview’s Crop tool with a fixed aspect ratio, changing the values in the size spinboxes now works properly (Alban Boissard, Gwenview 22.08)

Fixed a semi-common way that Plasma could crash when you remove a panel that has a System Tray widget on it (Fushan Wen, Plasma 5.24.6)

In the Plasma Wayland session, KWin no longer crashes when you hit Alt+Tab while the context menu for a window titlebar is visible (Xaver Hugl, Plasma 5.24.6)

The Overview effect no longer shows your panels, confusing you into thinking they’re interactive when they’re really not (Marco Martin, Plasma 5.24.6)

In the Plasma Wayland session, when something is recording your screen, the icon that appear in your system tray to notify you of this now appears in the visible part of the tray where you’ll actually see it, instead of only in the popup where it would be missed and fail to achieve its purpose in life (Aleix Pol Gonzalez, Plasma 5.24.6)

System Monitor Widgets now load handmade presets correctly. Note that you will need to remake your presets for this to work (Arjen Hiemstra, Plasma 5.24.6)

When you’ve set Discover to restart automatically after installing updates, now it only does so if all of the updates were applied successfully (Aleix Pol Gonzalez, Plasma 5.24.6)

In the Plasma Wayland session, when a KDE app is activated from another KDE app, the activated app now raises itself, just like it does on X11. This also makes the launch feedback animation work for apps launched from Kickoff, KRunner, and other pieces of KDE software! (Aleix Pol Gonzalez, Plasma 5.25) Note that when an app is activated and does not raise as you would expect, if either (or both) of the apps is a 3d-party app, it’s because that app needs to implement the xdg_activation_v1 Wayland protocol

In the Plasma Wayland session, a severe visual glitch experienced by users of NVIDIA GPUs has been fixed (Erik Kurzinger, Plasma 5.25)

In the Plasma Wayland session, hitting Meta+V to show a menu of the clipboard contents now shows an actual menu at the actual cursor position, rather than a standalone window in the center of the screen (David Redondo, Plasma 5.25)

In the Plasma Wayland session, you can now activate global shortcuts while dragging a window (Arjen Hiemstra, Plasma 5.25)

The Digital Clock applet’s “Copy to Clipboard” menu item now respects whether you’re using 24-hour time or 12-hour time (Felipe Kinoshita, Plasma 5.25)

Icon previews are once again shown for files on NFS or NTFS drives, the Trash, Plasma Vaults, KDE Connect mounts, and other non-local locations (David Faure, Frameworks 5.94). Note that this means preview generation can once again cause slowdowns and freezes in Dolphin when accessing those locations if they are slow, and we are working on a better way to avoid this without throwing the baby out with the bathwater by disabling previews entirely!

When you drag-and-drop an image onto your desktop and choose “Set as Wallpaper”, it will now automatically switch to the correct wallpaper plugin that supports single image wallpapers if you were currently using something different (Fushan Wen, Frameworks 5.95)

User Interface Improvements

When you provide incorrect authentication credentials on the lock or login screens, the whole UI now shakes a bit (Ivan Tkachenko, Plasma 5.25):

Tabs in GTK apps using the Breeze GTK theme now match the tab styling in Qt and KDE apps (Artem Grinev, Plasma 5.25)

Menubars and areas that use the menubar color in GTK apps using the Breeze GTK theme now use the header color as expected, if you’re using a color scheme with header colors (Artem Grinev, Plasma 5.25):

Toolbar buttons with icons and toolbar buttons without icons now share the same text baseline, so their text will always align vertically (Fushan Wen, Plasma 5.25):

In the Plasma Wayland session, multi-finger touchscreen gestures (Did you know that KWin has touchscreen gestures?) now follow your fingers just like touchpad and edge swipe gestures do! (Xaver Hugl, Plasma 5.25)

In the Plasma Wayland session, actions that trigger when you touch a screen edge are now disabled by default while there are any full screen windows, which improves the UX for games where you touch screen edges a lot (Aleix Pol Gonzalez, Plasma 5.25)

The Dictionary widget now shows you an appropriate error message when it can’t fetch the definition (Fushan Wen, Plasma 5.25):

The weather widget no longer shows decimals for its temperature display when used on a Panel (me: Nate Graham, Plasma 5.25):

On System Settings’ Login Screen (SDDM) page, the “Halt command” and “Reboot command” text fields are now editable, so you can type in a command by hand, or add a command-line argument to it if you’d like, instead of only being able to choose a command using the Open dialog (Someone going by the pseudonym “oioi 555, Plasma 5.25)

…And everything else

This blog only covers the tip of the iceberg! Tons of KDE apps whose development I don’t have time to follow aren’t represented here, and I also don’t mention backend refactoring, improved test coverage, and other changes that are generally not user-facing. If you’re hungry for more, check out, where you can find more news from other KDE contributors.

How You Can Help

If you’re a developer, check out our 15-Minute Bug Initiative. Working on these issues makes a big difference quickly!

Otherwise, have a look at to discover 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!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

Categories: FLOSS Project Planets

KDE Ships Frameworks 5.94.0

Fri, 2022-05-13 20:00

Saturday, 14 May 2022

KDE today announces the release of KDE Frameworks 5.94.0.

KDE Frameworks are 83 addon libraries to Qt which provide a wide variety of commonly needed functionality in mature, peer reviewed and well tested libraries with friendly licensing terms. For an introduction see the KDE Frameworks release announcement.

This release is part of a series of planned monthly releases making improvements available to developers in a quick and predictable manner.

New in this version Baloo
  • [Timeline KIO] Don’t announce that we can write
Breeze Icons
  • Add view-left-new action
  • New debug step icons
Extra CMake Modules
  • Drop lib prefix when building for Windows (MinGW)
  • Allow ecm_add_{qt,}wayland_{client,server}_protocol take targets
  • ECMQueryQt: always use CMake target to find the qmake/qtpaths binary
  • KDEGitCommitHooks: only configure pre-commit hook if needed
  • Make replace not block because of missing item removal
  • Add ResultModel::forgetResources method
KDE Doxygen Tools
  • only bootstrap when explicitly asked for
  • Add a dummy install target to cmake
  • Create UIDs if necessary (bug 339726)
  • Fix filtering of plugin in KPluginWidget
  • Check executables exist in PATH before passing them to QProcess
  • KPluginModel: Add method to get KPluginMetaData config object for given plugin id
  • KPluginDelegate: Add configTriggered signal
  • Refactor QML components of MPluginSelector to have less dependencies and have better layout
  • KPluginModel: Add isSaveNeededChanged singal
  • Import AboutPlugin dialog from QML
  • Expose proxy sort model as private QML API
  • Create QML version of KPluginSelector
  • Allow consumers to get sort proxy model
  • Export the KPluginModel class & make it usable from QML
  • KConfigGroup: fix writePathEntry/readPathEntry roundtrip for symlinks
  • Support storing QUuid
  • KCommandBar: remove installed event filter in destructor (bug 452527)
  • [kcolorschememanager] Rework and improve auto theme switching (bug 452091)
  • [kcolorschememanager] Don’t save colors on application start
  • Move kstatefulbrush implementation to its own file
  • fix: KRecentFilesAction saveEntries and loadEntries use the correct group when no group is passed
  • Add move constructor and assignment operator for KColorScheme
  • Make it clear that KStandardAction::name gives you ascii
  • KPluginMetaData: Fix setting of MetaDataOption when building without deprecations
  • processlist: don’t call procstat_getpathname() at all (FreeBSD)
  • ListOpenFilesJob: avoid creating the processlist on FreeBSD multiple times
  • Add PlaceholderMessage to GridView KCMs
  • Check executables exist in PATH before passing them to QProcess
  • Create and install version header file
  • exiv2extractor: add support for Canon CR3 raw image
  • Add BUILD_RUNTIME option (default ON)
  • x11: Implement deactivation
  • Add KGlobalAccel::globalShortcutActiveChanged
KDE GUI Addons
  • Un-pluginify modifierkeyinfo
  • Add plugin for wayland keystates
  • Add QML API for the sun and moon computations
  • New function for plasma to generate holidays without astro seasons (bug 445324)
  • Report intermediate lunar phases as well
  • Category added as parameter
  • Add functions for holiday only
  • Remove double entries and correct indian- (bug 441275)
  • KF5I18nConfig: Add missing find_dependency call
  • avif: prepare for breaking change in libavif
  • XCF: Support to QImageIOHandler::Size option
  • psd: Fix crash on broken files
  • psd: duotone read
  • psd: Don’t crash with broken images
  • psd: Header depth has to be 8 for CM_INDEXED color_mode
  • psd: Protect against broken images
  • avif: lossless support
  • psd: Don’t assert on broken files
  • PSD: Performance improvements and support to missing common formats
  • Temporarily revert “Consider slow files as remote files in previewjob”
  • KFileWidget: set standard zoomIn/Out keyboard shortcuts
  • KFileWidget: allow icon sizes to go up to 512 (bug 452139)
  • PreviewJob: consider all the available thumbnail cache pool sizes
  • dropjob: Extract Ark data in ctor (bug 453390)
  • dropjob: upstream ark behaviour from various file view implementations
  • KFileWidget: KF6, fix view size glitch on initial show
  • Don’t put job/ioworker on hold after getting the mimetype (bug 452729)
  • Don’t build kio_trash on Android
  • Remove unused Blkid dependency
  • Mark setSubUrl for cleanup in KF6
  • KCoreDirLister: modernise for loops
  • [KUrlNavigatorPlacesSelector] Disconnect setupDone signal when done
  • [KUrlNavigatorPlacesSelector] Do storage setup also when requesting a new tab (bug 452923)
  • [KFilePlacesView] Pass widget to QStyle::styleHint
  • Revert “Replace He with They in Doc not found page”
  • KFileItemDelegate: Add a semi-transparent effect to the icons of hidden files
  • [WidgetsAskUserActionHandler] Use WarningYesNo for permanently deleting files
  • [KDirOperator] Use QSortFilterProxyModel::invalidate() instead of ‘fake resorting’
  • KFilePlacesView: use animations only if QStyle::SH_Widget_Animation_Duration > 0 (bug 448802)
  • Replace He with They in Doc not found page
  • KFilePlacesModel: make it more accessible from QML
  • KUrlNavigator: offer open in new window action too (bug 451809)
  • Prepare KCoreDirLister::matches(Mime)Filter to be private
  • KDirOperator: do not overwrite standard back actions
  • KFilePlacesView: Improve touch support
  • KCoreDirLister: handle dir permission change in non-canonical paths
  • KCoreDirLister: handle file removal in non-canonical paths
  • KRecentDocument: fix erroneous messages about overwriting
  • KRecentDocument: ensure the path to the XBEL file existss (for CI)
  • Fix ~KTcpSocket crash with libc++ (e.g. FreeBSD)
  • ScrollablePage: Stop duck-typing QML types
  • SwipeListItem: Expose the width of overlayLoader
  • Dialog: Unbreak standardButton() method
  • ApplicationItem: Fix Shortcut’s warning about sequence vs. sequences
  • ApplicationItem: Clean it up a bit
  • columnview: Fix memory leak caused by QQmlComponent::create
  • columnview: Remove m_attachedObjects
  • AbstractApplicationItem: Fix copy-pasta mistake
  • correctly hide the bottom floating buttons when ther eis a page footer
  • ToolBarPageHeader: Do not assign undefined to real values
  • ColumnView notifies for contentChildren when page is removed (bug 452883)
  • ActionToolBar: fix moreButton visibility (bug 449031)
  • LoadingPlaceholder: remove redundant explanation
  • Improve ListItemDragHandle
  • Add LoadingPlaceholder component
  • AboutPage: Prevent infinite loop (bug 447958)
  • PlaceholderMessage: add types
  • Introduce TabletModeChangedEvent
  • [doc]: Remove double inheritance arrow for Kirigami.PagePoolAction
  • Fix assertions in KDescendantsProxyModel (bug 452043)
  • Fix punctuation/whitespace of runtime rate-limited deprecation warnings
  • Action: simplify expression for engine property
  • Deprecate KNS3::QtQuickDialogWrapper::exec (bug 450702)
  • qtquickdialogwrapper: Fix memory leak caused by QQmlComponent::create (bug 452865)
  • Use Kirigami.LoadingPlaceholder component
  • Delete our own custom PlaceholderMessage
  • Dialog: Port to Layouts
  • Dialog: use a real ToolBar for the footer instead of a homemade one
  • Dialog: Add a little separator line between footer and content
  • Convey lack of hotness visually in placeholder message
  • Don’t send alpha channel if pixmap has none
KPackage Framework
  • Add avatar image provider
  • KPtyProcess: call childProcessModifier() of parent class first
  • Use ECM_MODULE_DIR instead of ECM_DIR/../modules
  • Make Qt::Gui dependency for deprecation free builds internal
  • Deprecate public KConfigGroup include of AbstractRunner class
  • KService: Do not link KCoreAddons and KConfig publicly when building without deprecations
  • kservice.h: Wrap public KCoreAddons includes in deprecation macros
  • fix vector init in commands()
  • inc ui file version after action name fixes
  • EmulatedCommandBarTest: port from processEvents to QTRY_VERIFY
  • create commands and motions once
  • avoid storing instance in commands/motions
  • avoid cursor move on insert of line at EOF on save (bug 453252)
  • use proper name for selection menu
  • Multicursors: Use shorter actions names
  • Multicursors: Move current cursor to end of line when cursors are created from selection
  • more deprecation fixes for Qt 6
  • Fix completion leaks, don’t use null parent
  • Add option to show folding markers on hover only
  • Paint using path once instead of painting multiple rects
  • Fix background visible through selection with custom painted selection
  • vimode: add another motion command for moving down one line
  • Fix help link for editing command line
  • Fix crash when ModeMenuList wasn’t init but we try to reload it (bug 452282)
  • Enable auto-brackets by default
  • Improve Color theme config page
  • Don’t use GenericDataLocation on Android
  • client: implement plasma-surface openUnderCursor
  • Fix include path in the generated pkgconfig file
  • [plasmawindowmanagement] Add resourceName
  • Use KDatePickerPopup in KDateComboBox
  • Add support for custom date word maps, as done in KDateComboBox
  • Share date range support between KDateComboBox and KDatePickerPopup
  • Allow to change KDatePickerPopup modes at runtime
  • Implement date word actions as done in KDateCombobox
  • Build the date picker menu dynamically on demand
  • Add KDatePickerPopup
  • KPageDialog: Add a new face type with a flat list of small icons
  • ui_standards.rc: add tag so kate can insert a menu between Edit and View
  • Fix saving of state config if one has autosave enabled (bug 451725)
  • Replace OS-specific system information code with QSysInfo (bug 450862)
  • WirelessNetwork: Fix reference access point for the active network
Plasma Framework
  • IconItem: Allow specifying a custom loader
  • plasmastyle: Import PlasmaCore in MenuStyle
  • Don’t assert if the theme is not found, just warn
  • desktoptheme: Install plasmarc
  • plasmaquick: Fix memory leak caused by QQmlComponent::create
  • Revert “Prevent tooltips from being incorrectly dismissed” (bug 439522)
  • wallpaperinterface: Add some APIs needed for wallpaper accent color support
  • Fix use-after-free in ContainmentInterface (bug 451267)
  • Fix osd dialog position (bug 452648)
  • mark plasmapkg as nongui executable
  • Fix check for argument length in DataEngine loader (bug 452596)
  • desktoptheme: Convert desktop to json files
  • desktoptheme: Separate config from theme metadata
  • Convert desktop files of plugins to json
  • examples: Convert desktop files of KPackages to json
  • Keep PlasmaComponents.Highlight on its former behaviour (bug 452555)
  • Dialog: Do not update layout parameters while hidden (bug 452512)
  • Wrap KPluginInfo includes in deprecation wrappers
  • PlaceholderMessage: Remove Kirigami references
  • PlaceholderMessage: add types
  • PC3 toggle controls: fix odd heights misaligning indicators (bug 447977)
  • Fix search field left padding when icon is hidden
  • ExpandableListItem: deprecate contextmenu and allow actions+custom view
  • Deprecate DataEngine related code in Plasma::PluginLoader
  • Plasma::Theme: Port last KPluginInfo usage
  • Plasma::Theme: Allow packages to ship metadata.json file, move config to separate file
  • Add include needed by Qt6 forgotten in d74a8286e1
  • Remove duplicate header between .h/.cpp file
  • Fix out-of-bounds read on the Aztec special char table
  • Enable macOS support
  • Fix PrisonScanner target name
  • Consider flipped video frames when computing the barcode positioon
  • Add barcode scanner component for barcode scanning from live video
  • Port to ecm_add_qml_module
  • Remove infoChanged signal from KQuickStyleItem
  • Replace connect to self in KQuickStyleItem with direct method calls
  • Recalculate metrics when tablet mode changes
  • Fix use of a no longer existing id
  • udev/cpuinfo_arm: Add missing CPU ID
Syntax Highlighting
  • cmake.xml: Updates for CMake 3.23
  • Fix haxe rawstring escaping
Security information

The released code has been GPG-signed using the following key: pub rsa2048/58D0EE648A48B3BB 2016-09-05 David Faure Primary key fingerprint: 53E6 B47B 45CE A3E0 D5B7 4577 58D0 EE64 8A48 B3BB

Categories: FLOSS Project Planets

Web Review, Week 2022-19

Fri, 2022-05-13 07:30

Let’s go for my web review for the week 2022-19.

NVIDIA Releases Open-Source GPU Kernel Modules | NVIDIA Technical Blog

Tags: tech, gpu, nvidia, foss

At last! Maybe we can finally dream of NVIDIA turning into a good citizen on our platforms?

Wireless is a trap |

Tags: tech, wifi, bluetooth, complexity

Indeed, we loath wires… but going wireless has its own set of issues. It never completely breaks but it can easily degrade for no apparent reason which could be anywhere in the stack.

Complexity is the mind killer

Tags: tech, complexity, simplicity, xp, craftsmanship

I definitely agree with this. Managing complexity is our trade.

Scapy: low level packet hacking toolkit for Python – Trickster Dev

Tags: tech, python, networking, security

Looks like a very interesting toolkit for low level network related or security related operations.

I’m All-In on Server-Side SQLite · Fly

Tags: tech, databases, sqlite, backend

The tone of the article isn’t exactly to my liking, sounds “too good to be true” at times ignoring important details driving the choices (despite some warnings early on). Still, depending on the amount of data stored in your database, SQLite looks increasingly viable on the server, replication even coming down the road.

Modeling Finite State Machines with Rust | Ramnivas Laddad

Tags: tech, safety, type-systems, rust

I like it when type systems can express this kind of constraints. It clearly allows to catch mistakes early in the development cycle.

Bottled water monopolist admits recycling is bullshit

Tags: ecology, lobbying, plastics

The best waste is the one you didn’t create in the first place. If you still had doubts that recycling plastics is a scam, it’s definitely something to read. It was again a trick to turn into a “personal responsibility” something which was a collective failure.

Bye for now!

Categories: FLOSS Project Planets

Structured Bindings with Qt SQL

Thu, 2022-05-12 05:00

Some time ago, I wrote a post about integrating Qt’s associative containers with the fancy new C++ features, range-based for loops with structured bindings.

That post inspired KDAB’s own Giuseppe D’Angelo to add the asKeyValueRange member function to both QHash and QMap. Now it’s possible to iterate over them with a simple range-based for loop, like so:

for (auto [key, value] : map.asKeyValueRange()) { // ... }

The second part of my previous post demonstrates how we can iterate over Qt SQL results using a range-based for loop as if it were an ordinary collection. In addition, it announces this second part of the post that shows you how to add the support for structured bindings into the mix.

Structured Bindings, Revisited

Recall that structured bindings allow us to decompose structures such as std::pair and QPair, so that we can give more intuitive names to the fields in those structures than the first and second names provided by both pair types:

auto [x, y] = mousePosition();

In the previous example, when the range-based for loop iterates over map.asKeyValueRange(), it takes each key-value pair from the map and assigns the name key to the first element of the pair and the name value to the second element.

Internally, the pair is stored in an invisible variable, and the names key and value just refer to the fields inside of that variable.

Out-of-the-box, structured bindings can also be used with arrays, tuple-like types, or, a bit less useful outside of generic programming, with ordinary user-defined structures:

std::tuple<bool, QString, QString> employee; auto &[active, name, team_name] = employee; Employee employees[2]; auto &[first_employee, second_employee] = employees; struct Employee { bool m_active; QString m_name; QString m_team; }; Employee employee = ...; auto &[active, name, team_name] = employee; Structured Bindings Support for Custom Types

It is also possible to make our own types decomposable with structured bindings, by making sure our types implement the so-called tuple protocol or, in other words, by making our types look like tuples.

Imagine we don’t want the m_active member variable to be seen when using structured bindings on the previously defined Employee type. Instead, we just want to be able to bind m_name and m_team:

auto &[name, team_name] = employee;

In order to specify how our type should be decomposed with structured bindings, we need to define a few things:

  • into how many values an instance of our type can be decomposed;
  • the type of each of those values;
  • a getter for each of those values.

The first part of the tuple protocol is simple — we need to specialize the std::tuple_size template for our type Employee. Since we only want to bind m_name and m_team, the size of our tuple-like type will be 2.

#include <utility> ... namespace std { template<> struct tuple_size<::Employee> { static constexpr std::size_t value = 2; }; }

The next step is to specialize the std::tuple_element template:

namespace std { template<> struct tuple_element<0, ::Employee> { // The type of m_name using type = QString; }; template<> struct tuple_element<1, ::Employee> { // The type of m_team using type = QString; }; }

The value we defined in the std::tuple_size specialization tells the compiler how many values it will get when it decomposes an instance of Employee, and the types we defined in the std::tuple_element specializations are the types of those values. In our case, both values are QStrings.

The last step is to create a get function template. It can be a member of Employee, but it can also be a free function (non-member) template.

template <std::size_t Idx> auto& get(Employee& employee) { if constexpr (Idx == 0) return employee.m_name; if constexpr (Idx == 1) return employee.m_team; }

It’s worth noting that this implementation will not accept const objects and you’ll need to provide a get implementation that takes a reference to a const Employee, if you want to support those as well.

Decomposing QSqlRecord

Now that we know what we need to implement in order for our types to be usable with structured bindings, we can try to do it with QSqlResultIterator, which we implemented in part 1 of this blog post.

As a reminder, in the first part of the post, we implemented the QSqlResultIterator class that can be used to iterate over all results of a QSqlQuery. We also implemented operator[] on it, which allows us to access fields in a result.

class QSqlResultIterator { // ... QVariant operator[] (int index) const { return m_query.value(index); } };

We can use this to base the get function template on. To demonstrate that get doesn’t need to be a free function, we will implement it as a member of QSqlResultIterator:

class QSqlResultIterator { // ... template <std::size_t Idx> QVariant get() const { return m_query.value(index); } };

The remaining things that need to be implemented are the specializations of std::tuple_size and std::tuple_element.

Since all values in QSqlResult are QVariants, specializing std::tuple_element is trivial. For any index we’re given, we just need to set type = QVariant:

namespace std { template<std::size_t Idx> struct tuple_element<Idx, QSqlResultIterator> { using type = QVariant; }; }

The std::tuple_size, on the other hand, is tricky. SQL queries are a runtime thing, and we need to know the number of fields in a record at compile time. This means that we need to allow the user to explicitly define the number of fields in a record when creating the QSqlResultIterator. One way to do it is to make QSqlResultIterator a class template with one std::size_t parameter:

template <std::size_t FieldCount> class QSqlResultIterator { // ... };

This will allow us to define everything we need to allow QSqlResultIterator to be used with structured bindings:

template <std::size_t FieldCount> class QSqlResultIterator { template <std::size_t Idx> QVariant get() const { return m_query.value(index); } // ... }; namespace std { template<std::size_t FieldCount> struct tuple_size<QSqlResultIterator<FieldCount>> { statuc constexpr std::size_t value = FieldCount; }; template<std::size_t Idx, std::size_t FieldCount> struct tuple_element<Idx, QSqlResultIterator<FieldCount>> { using type = QVariant; }; }

We could even add a few static_asserts that would check that Idx is less than FieldCount everywhere.

Broken Range-based For Loop Use-case

When we added the FieldCount template parameter to QSqlResultIterator, we broke the use-case we had in the part 1 of this post. We now require FieldCount to be specified explicitly when an instance of QSqlResultIterator is created, and we are not creating it anywhere explicitly.

As a reminder, the QSqlResultIterator was instantiated by the range-based for loop which called begin on the QSqlQuery instance we passed to it:

for (auto result: query) { // ... }

It happened behind the scenes and we cannot control how begin is called by the range-based for loop to be able to pass in FieldCount somehow.

Or, can we?

We can write a simple wrapper similar to what we did for asKeyValueRange. Then, instead of begin being defined for QSqlQuery directly, it would be defined for that wrapper, and it would be able to create QSqlResultIterator with the proper FieldCount value.

It could look something like this:

template <std::size_t FieldCount> class QSqlResultRange { public: QSqlResultRange(QSqlQuery query) : m_query(std::move(query)) {} QSqlResultIterator<FieldCount> begin() { return { m_query }; } QSqlResultSentinel end() const { return {}; } private: QSqlQuery m_query; };

Then we can use it as follows:

for (auto [active, name, team] : QSqlResultRange<3>(query)) { // ... } Adding Types to the Mix

So far, we’ve implemented a range object that allows us to iterate over SQL results using a range-based for loop with structured bindings.

In the previous example, we get bindings active, name and team that all have QVariant type.

Can we improve the type-safety of this code, considering our almost always storing concrete types in a database and having to unwrap all QVariants, manually, is tedious and error prone?

Can we specify that the range object returns a bool and two QStrings in each iteration?

As usual in C++, the answer here is a resounding yes. The only thing that we need to do is replace all occurrences of the FieldCount parameter with a variadic pack of types, which will allow us to specify the exact types we expect to get in each resulting row of an SQL query.

In order avoid mixing these with the previously defined types, we’ll add Typed to the names of classes we’ve created so far.

// We want to allow the user to specify the types // of the fields in an SQL row template <typename ...Types> class QSqlResultTypedIterator { public: // The constructor and all the basic functions // we had in QSqlResultIterator remain unchanged QSqlResultTypedIterator(QSqlQuery& query) : m_query(query) {; } QSqlResultTypedIterator& operator++() {; return *this; } bool operator!=(QSqlResultSentinel sentinel) const { Q_UNUSED(sentinel); return m_query.isValid(); } QSqlResultTypedIterator& operator*() { return *this; } // The only one that differs is the tuple-compatible // get member function. It can return different types // depending on the provided index. template <size_t Idx> auto get() const { using ResultType = std::tuple_element_t<Idx, std::tuple<Types...>>; // We can assert that the type stored inside of QVariant // is the type that we expect to be in it. Q_ASSERT(m_query.value(Idx).canView<ResultType>()); // .value returns a QVariant. Then we call .value // on said variant to convert it to the desired type. return m_query.value(Idx).value<ResultType>(); } private: QSqlQuery& m_query; }; namespace std { // The tuple_size for QSqlResultTypedIterator is the // number of types inside of Types... which we can // easily get with sizeof...(Types) template<typename... Types> struct tuple_size<QSqlResultTypedIterator<Types...>> : public integral_constant<size_t, sizeof...(Types)> {}; // The simplest way to implement tuple_element on our type // is to just base it on the implementation of std::tuple itself. // When we are asked for tuple_element<Idx, QSqlResultTypedIterator<Types...>>, // we will just replace QSqlResultTypedIterator with std::tuple, // and return tuple_element<Idx, std::tuple<Types...>> template<std::size_t Idx, typename... Types> struct tuple_element<Idx, QSqlResultTypedIterator <Types...>>: tuple_element<Idx, std::tuple <Types...>> { }; } // The complex part was in the QSqlResultTypedIterator, and the // range object remains as simple as QSqlResultIterator was. // The only change is that FieldCount is replaced by Types... everywhere template <typename ...Types> class QSqlResultTypedRange { public: QSqlResultTypedRange(QSqlQuery query) : m_query(std::move(query)) { } QSqlResultTypedIterator<Types...> begin() { return { m_query }; } QSqlResultSentinel end() const { return {}; } private: QSqlQuery m_query; }; Wrap-up

This was a lengthy post to follow, and it had a lot of non-trivial code for something as simple as being able to write:

for (auto [active, name, team] : QSqlResultTypedRange<bool, QString, QString>(query)) { qDebug() << "active(bool):" << active; qDebug() << "name(QString):" << name; qDebug() << "team(QString):" << team; }

While this might not look like it is worth doing, remember that this is something you need to write only once and you will use it a lot, if you have an application that is SQL-heavy.

It will make your code more easy-to-read and as type-safe as possible when SQL is concerned, since the debug builds will assert that you are not trying to coerce values of one type into being something that they are not, when crossing the border between SQL and C++.

It is also easily extendible, to allow the user to skip the conversion from QVariant to a specific type by skipping the .value<ResultType>() part when the user-specified QVariant is the desired type, or to support using wrapper types such as std::optional when you have fields in an SQL table that can be NULL.


About KDAB

If you like this article and want to read similar material, consider subscribing via our RSS feed.

Subscribe to KDAB TV for similar informative short video content.

KDAB provides market leading software consulting and development services and training in Qt, C++ and 3D/OpenGL. Contact us.

The post Structured Bindings with Qt SQL appeared first on KDAB.

Categories: FLOSS Project Planets

KDE Gear 22.04.1

Wed, 2022-05-11 20:00

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations, including:

  • dolphin: The terminal panel will keep in sync with quick folder changes now, Commit, #391380, #416690
  • kate: Fix crash on session restore, Commit, #453152
  • kalendar: Fix ’next week’ button in the week’s view Commit

Distro and app store packagers should update their application packages.

Categories: FLOSS Project Planets

What’s cooking in KWin? Plasma 5.25

Mon, 2022-05-09 03:47

We’re past the soft feature freeze of the next Plasma release, so it’s a good time to step back and a have look at the work that has been done in KWin during 5.25 development cycle.

Gesture improvements

Credits: Eric Edlund, Marco Martin, Xaver Xugl

A lot of focus has been put into improving gesture integration in the Wayland session. In 5.24, the desktop grid effect got support for real-time gestures. In 5.25, the support for real-time gestures has been expanded. Effects such as slide, window aperture (animates windows when transitioning to the “show desktop” mode), and overview now support animations that “follow fingers.”

The slide effect follows fingers when switching between virtual desktops using gestures Merge of kwayland-server and kwin

Credits: me

That’s not a user-facing change, but it’s really important to KWin developers. Some history trivia. KWin used to contain Wayland glue code, eventually it was split in a separate KDE Frameworks library called KWayland. The idea was to provide reusable components that can be useful not only to KWin but also other Wayland compositors. The split is better described in

At the beginning, things were good. If you need to implement a Wayland protocol, add corresponding wrappers in KWayland and then implement the protocol in KWin. However, being KDE Frameworks started presenting problems. KDE Frameworks provides strong API and ABI compatibility guarantees, which is very compelling for consumers but it can be a major source of headache for developers. For example, if a few bad design decisions were made, you cannot simply go back and correct the mistakes, you are going to live with that until the next major version release when it’s okay to make breaking changes. That’s what happened in KWin and KWayland, we made a couple of bad design choices that fired back at us and eventually resulted in a period of technical debt.

As a way out of technical debt, we made a hard decision to split the server side out of KWayland in a separate library called KWaylandServer, which provided no API or ABI compatibility guarantees between minor releases, but some between patch releases. Most of the client APIs in KWayland were deprecated too.

The split of the server side from KWayland in a separated library was a huge relief and it massively accelerated KWin development pace, that had user-facing effects too. Plasma on Wayland session started receiving less complaints (around Plasma 5.18 – 5.20 or so) from users because we were free to change KWin and KWaylandServer the way we thought was the best.

However, KWaylandServer also started showing cracks. The first problem is that it didn’t gain a strong user base. Its the only user was KWin and there weren’t any signs of new users. The second problem is that we gradually switched to qtwaylandscanner so we ended up writing wrappers for wrappers. The third problem is that wayland protocol implementations cannot exist in vacuum and they need to communicate with other compositor components, e.g. renderer; because no such components were present in KWaylandServer, we had to add glue code that made things more complicated. Also, perhaps we tried to fix a wrong problem by providing a library with Qt friendly wrappers for libwayland. Things such as the DRM backend or the scene graph are far more challenging to implement and maybe we should put focus onto making them reusable instead of wrappers.

Regardless, a year or so ago we agreed that it’s worth bringing server-side wayland code back into KWin. In 5.25, we were finally able to do the merge. That allows us to simplify many wayland protocol implementations, fix some design issues and a few known bugs.

Present Windows and Desktop Grid effects rewritten in QML

Credits: Marco Martin

We started experimenting with implementing some fullscreen effects in QML in 5.24. In order to continue that effort, the Present Windows and Desktop Grid effects were rewritten in QML. The main advantage of QML is that we will be able to build more complex scenes without significantly sacrificing maintainability, for example blurring the desktop background only takes a couple of QML lines of code, in C++ it would be a lot more! The main focus with the rewrite was put on keeping feature parity between C++ and QML versions of Present Windows and Desktop Grid.

Desktop Grid implemented in QML Present Windows (now called “Window View”) effect implemented in QML Compositing improvements

Credits: Xaver Xugl, me

We continue pushing forward with our ambitious goal to make KWin utilize hardware output planes better and make it more efficient. Significant amount of work in 5.25 has been put into refactoring the DRM backend and compositing abstractions. Unfortunately, we won’t be able to get everything we wanted in 5.25, but hopefully Plasma/Wayland users will start benefiting from this work in the next Plasma release, i.e. 5.26.

As a part of the scene redesign goal, we made handling of invisible windows more efficient on Wayland. For example, if an invisible window wants to be repainted for whatever reason, KWin is going to ignore that request. It’s not an issue on X11, but it was challenging to implement that behavior on Wayland the “right way.” Also, if painting code in a Wayland application is driven by frame callbacks, KWin won’t send frame callbacks anymore if the window is invisible, e.g. minimized or on a virtual desktop that is not current, thus no precious CPU or GPU resources will be wasted.

Screencasting improvements

Credits: Aleix Pol Gonzalez

KWin/Wayland got a new screencasting mode that allows capturing a rectangular region on the screen. For example, this can be useful for building screen recording tools, etc.

New blend effect

Credits: David Edmundson

The blend effect provides an eye-candy animation when switching between dark and light themes.

Fixed Aurorae decorations having “sharp” corners

Credits: Michail Vourlakos

The blur effect is applied to the region beyond top-left corner

If you use a decoration theme powered by Aurorae decoration engine, then the decoration borders may not be as round as they are supposed to be. It’s been a long standing bug caused by the blur effect and lack of enough metadata in Aurorae decoration themes

The blur effect is applied as expected in 5.25 Window management refactors

Credits: Nils Fenner

KWin used to have a strange window class hierarchy that always created confusion among new contributors.

KWin used to use the word “client” to refer to managed windows, i.e. the ones with frames, but the word “client” means a totally different thing in the Wayland world, it represents the other endpoint connected to the compositor, e.g. an application. The word “toplevel” also means different things in KWin and the xdg-shell protocol, which is used by practically all Wayland applications to create “normal” windows and popups.

Toplevel and AbstractClient classes were merged into the base Window class with a far more intuitive name. That makes the class hierarchy simpler, and hopefully removes an obstacle for new contributors.

fbdev backend was dropped

The fbdev backend was in a bit-rotten state. With the emergence of simpledrm kernel driver, we decided to drop the fbdev in favor of the DRM backend, which is actively maintained.

Closing words

5.25 is going to be the biggest release by the scale of changes within recent years, which is both great and terrifying, so it’s more than ever important that as many as possible people give us feedback about the upcoming beta. Please join us at, which is going to be held on May 26th in, to help us to make this release smooth and amazing.

Categories: FLOSS Project Planets

Linux App Summit 2022

Sat, 2022-05-07 09:45

A week ago I attended Linux App Summit (LAS) 2022 in Rovereto, Italy. It was great to finally travel and meet people again, after more than two years. At the same time it would be naive to think the pandemic is over, and it’s still a few days too early for the final verdict on whether we managed to meet safely, but things look very promising so far.

LAS 2022 closing Traveling again!

LAS 2022 was the first time leaving the country for me since FOSDEM 2020. That also meant having the opportunity for quite some field testing of KDE Itinerary. It got me safely through three countries to Rovereto and back, passing all ticket and COVID certificate checks easily. I also had no other attendee yell at me for getting lost, but that might just as well be selection bias ;)

A few things were fixed on the way:

  • European international train tickets result in fairly large barcodes, to the point of not fitting on my relatively small phone display anymore. This case is now detected and the barcode is scaled down accordingly (something that we generally try to avoid, as it can reduce detectability).
  • Editing the address to an event reservation now also works when there was no address information available previously.
  • Geo-coding event locations was fixed in the presence of region information.
  • A few train stations along the way have floor level issues fixed in OSM now.
  • Weather forecasts for layover locations no longer wrongly include train trips in their time interval.

And a few more things popped up but have yet to be addressed:

  • Our address formatting code isn’t properly handling the region element in Italian addresses.
  • Selecting the right provider for realtime delay information can be improved on international trips, the operator and the ticker issuer might not be the same entity there, and usually the operating company has the better data.

As a nice bonus I also got to see the Brenner railway route before the Brenner base tunnel opens, and have some tasty local food in Italy :)

Meeting people again!

More importantly, this was also one of the very rare opportunities in more than two years to meet people in person. It was great to see some of the old KDE friends again, as well as to make some new contacts. Many thanks to all the people who made LAS possible!

The whole setup felt safe, with the hallway track and lunch generally happening outdoors, masks being the norm on the inside, and more COVID pass checks per day than I had seen in Germany in the past two years combined. I also did daily rapid antigen self-tests to further reduce the risk I might pose to others. So far I haven’t heard of any positive COVID tests following LAS, which is very encouraging.

Another interesting aspect is how well the event worked for remote participants. I’m quite sure hybrid events are here to stay, so we better make them work well. I find it very hard to judge that from just the onsite perspective though, feedback from remote participants will be important here.

Meta-topics aside, there’s of course also one of the core topics of LAS, collaboration with our colleagues from GNOME, which, unsurprisingly, everyone at LAS was very open to and interested in. I had interesting conversations on working together on maps data infrastructure, access to public transport data and energy efficiency/eco certification for example.

Energy efficient software

One of the talk highlights for me was Joseph’s presentation on Energy Conservation and Energy Efficiency with Free Software (video). I have been following this work from quite early on, so most of the content wasn’t exactly new to me, but I was particularly happy about seeing the wide interest in this subject, and the following discussions with other attendees on how to improve this.

If you want to get involved, there’s also a planned meeting dedicated to this in Berlin later this month on Saturday May 21st. Details can be found in the announcement.


While online meetings and events have become an invaluable tool, they still don’t manage to fully replace the effectiveness and social aspects of in person meetings. So I have my fingers crossed that we’ll see in a few days that there are ways to meet safely again. That should then hopefully allow a few more meetings this year (KF6 sprint, anyone?), and it makes me very hopeful for Akademy later this year.

Categories: FLOSS Project Planets

This week in KDE: New features and many bugfixes for Plasma 5.25

Sat, 2022-05-07 00:57

This week Plasma 5.25 reached its “soft feature freeze” date, at which point we don’t add any large new features or major code refactorings. This reduces risk and gives us a longer period of time to polish those changes before the final release. So as you can imagine, everyone rushed to merge their big stuff right before the deadline! As a result, this week I can present are tons of new features and important refactorings that fix multiple bugs. Check it out:

15-Minute Bugs Resolved

Current number of bugs: 70, same as last week. 2 added and 2 resolved:

The volume and brightness OSDs once again show their visual indicator bars on the lock and login screens (Ivan Tkachenko, Plasma 5.24.5)

When an application gives the system both an icon name and an image for its System Tray icon, the System Tray now prefers the icon name, so if there is such an icon in your icon theme, you’ll see that and it will respect your color scheme. This affected Telegram, for example (Vlad Zahorodnii, Plasma 5.24.6)

Current list of bugs

New Features

You can now optionally give your panel a “floating” appearance! In this mode, it still functionally behaves identically to a traditional panel, and clicks in the empty area will be forwarded to the panel. In addition, the panel “un-floats” when there are any maximized windows (Niccolò Venerandi, Plasma 5.25):

Discover now shows you apps’ level of access to resources on your system! When an app is sandboxed, you get a fine-grained list of exactly the things that the app automatically has permission to do (Suhaas Joshi and Aleix Pol Gonzalez, Plasma 5.25):

The presentation here is still a bit rough, and will probably be cleaned up by the time 5.25 ships

When you uninstall a sandboxed app in Discover, it now offers you the ability to easily delete the settings and user data if you want to (Aleix Pol Gonzalez, Plasma 5.25):

The Overview effect now offers the option to exclude minimized windows, just like Present Windows does (Marco Martin, Plasma 5.25)

Bugfixes & Performance Improvements

When you use Dolphin’s “Open Terminal” feature, it once again opens the terminal at the folder which is selected (if any) rather than always opening it at the current folder (Someone going by the pseudonym “oioi 555”, Dolphin 22.08)

Elisa now shows album art for songs and albums that have the covers embedded in the files, not just sitting next to them (Tranter Madi, Elisa 22.08)

System Monitor once again shows information for AMD GPUs (David Redondo, Plasma 5.24.6)

The Flickr and Simon Stålenhag Picture of the Day wallpapers no longer change more than once a day (Fushan Wen, Plasma 5.24.6)

Text for menu items in the Global Menu once again follows the color scheme of the Plasma Theme (me: Nate Graham, Plasma 5.24.6)

System Settings’ Display Configuration page now shows the correct refresh rates in more circumstances (Xaver Hugl, Plasma 5.24.6)

Fixed one of the ways that the kded daemon could crash in the Plasma Wayland session (David Edmundson, Plasma 5.25)

Under the hood, the Present Windows and Desktop Grid effects have been rewritten to use the same backend as the Overview effect, which fixes a grand total of 44 Bugzilla tickets (!!!), gives them consistent visual styling, and modernizes their code to keep them maintainable going forward (Marco Martin, Plasma 5.25)

System Monitor charts using the “Horizontal Bars” style are now able to meaningfully show values equal to or very close to 0 (Trent McPheron, Plasma 5.25)

Fixed a memory leak when changing your wallpaper plugin (Fushan Wen, Plasma 5.25)

When you change any of the paths in System Settings’ Locations page, any Places Panel bookmarks that pointed to the old locations are automatically updated to point to the new locations (Méven Car, Plasma 5.25)

System Monitor now shows the correct app icons for apps that were launched automatically at login (David Redondo, Plasma 5.25)

Breeze cursors are no longer ever so slightly smaller than they were intended to be (Chris Chris, Plasma 5.25)

Plasma no longer crashes if it can’t find the active theme (David Faure, Frameworks 5.94)

Dolphin no longer crashes when closed from the “Close Tab” list item from the command palette (Ahmad Samir, Frameworks 5.94)

Fixed a bug that could cause file transfers to SMB shares to fail the second and/or subsequent times you make a transfer (Harald Sitter, Frameworks 5.94)

Fixed a memory leak affecting many Kirigami-based applications (Fushan Wen, Frameworks 5.94)

User Interface Improvements

Kate now shows its toolbar by default (Christoph Cullmann, Kate 22.08)

Kate’s Menu bar has been re-arranged a bit to make each one less huge and intimidating. In particular, there is now a new “Selection” menu that holds actions which will be applied only to whatever is selected (Eric Armbruster, Kate 22.08):

Various KWin scripts that are implemented in JavaScript (such as the Show Desktop effect) now that follow your fingers when activated with a gesture. Activate Show Desktop with a Touch Screen swipe to see some magic! (Marco Martin, Plasma 5.25)

A bunch more KWin effects are now activatable using touch screen edge swipes (Marco Martin, Plasma 5.25)

When you set up fingerprint authentication, the lock screen now lets you immediately unlock by putting your finger on the fingerprint reader; no need to click the “unlock” button with en empty password field anymore! (David Edmundson, Plasma 5.25)

You can now add locations and places to the “Favorites” list/grid in Kickoff, Kicker, and the Application Dashboard (Méven Car, Plasma 5.25):

Klipper’s configuration window has been re-organized a bit to have a new “Action Menu” page, which holds settings relevant to the actions menu when you are using any Klipper actions; if you’re not, you can safely ignore it entirely (Jonathan Marten, Plasma 5.25)

File open/save dialogs and inline icon views in various apps such as Kdenlive now let you scale icons up to 512 px size (Ahmad Samir, Frameworks 5.94)

…And everything else

This blog only covers the tip of the iceberg! Tons of KDE apps whose development I don’t have time to follow aren’t represented here, and I also don’t mention backend refactoring, improved test coverage, and other changes that are generally not user-facing. If you’re hungry for more, check out, where you can find more news from other KDE contributors.

How You Can Help

If you’re a developer, check out our 15-Minute Bug Initiative. Working on these issues makes a big difference quickly!

Otherwise, have a look at to discover 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!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

Categories: FLOSS Project Planets

Web Review, Week 2022-18

Fri, 2022-05-06 03:57

Let’s go for my web review for the week 2022-18. After a one week break, I mentioned we might have a double issue next… Here it is!

EU Joins Mastodon Social Network, Sets Up Its Own Server | PCMag

Tags: tech, social-media, politics

This is very good exposure to both Mastodon and PeerTube.

GNOME patent troll stripped of patent rights

Tags: tech, patents, law

Excellent news, hoping to see more such bogus patents cancelled. Also, one can hope, that patent offices would start becoming less sloppy…

Blockchain is Dangerous Nonsense | Eisfunke

Tags: tech, blockchain, web3, nft, scam

Behind the hype… a speculative bubble completely out of touch with reality.

Magic-trace collects and displays high-resolution traces of what a process is doing

Tags: tech, debugging, profiling, tracing, performance

This looks like a very interesting tracing tool for debugging and profiling purposes.——magic-trace

Python’s “Type Hints” are a bit of a disappointment to me

Tags: tech, python, type-systems, mypy

A good reminder that it’s not all rosy with Python type-hints. There’s definitely room for improvements.


Tags: tech, rust, python, backend, web

Looks like it’s still in the very early days but the overall approach looks interesting.

Chopping the monolith

Tags: tech, microservices, architecture

Good arguments around the microservices hype. People advocate for it way more than reasonable, this applies only in rare contexts.

Lies we tell ourselves to keep using Golang

Tags: tech, go, rust, type-systems, complexity

This is in part a rant but lots of points in there are very valid. This is in part why I don’t find Go a very compelling option so far. Modern tooling indeed, nice runtime in some areas but leaves way too much of the complexity in imperative code.

PyScript | Run Python in your HTML

Tags: tech, python, webassembly, browser

It was only a matter of time until this kind of things would be doable through webassembly. I’m wondering about the size of the payloads the browser needs to download though.

How I fell in love with low-js

Tags: tech, frontend, backend, browser, javascript, html

There is indeed a trade-off approach available nowadays between “backend computes the whole page” and “frontend computes it all in JS”. This sounds like an interesting patch depending on the project context.

Why Your CSS is Always Messy and Chaotic – Understanding CSS Complexity

Tags: tech, web, frontend, css

Good explanation of why the complexity of CSS code quickly gets out of control.


Tags: tech, frontend, interviews

This is indeed a nice set of tasks to evaluate a frontend tech or your mastery of it. Potentially usable in interviews?

IBM’s asshole test — johnpublic

Tags: hr, interviews

OK, if true this is indeed an interesting test… kind of a social experiment really. Probably quite a bit ambiguous though.

11 Principles of Engineering Management

Tags: management

An interesting set of management principles. Most make sense, a couple might be contextual.

Having Career Conversations

Tags: management, career, hr

Lots of nice advices, both for mentors and mentees. This is definitely hard work but it’s worth it for people to grow.

Taking control of your professional growth: a personal experience

Tags: management, hr, career

About growth again, definitely from the point of view of the mentee though. This looks like a nice and lean framework to figure out where you are and where you want to go.

Gen Z does not dream of labor

Tags: management, work, life, remote-working

I find the title somewhat limiting due to the “Gen Z” label, but content is way more balanced even though fairly US centric. There are a few good lessons about work perception by people.

The Most Horrible Parasite: Brain Eating Amoeba - YouTube

Tags: science

The title says it all… indeed really creepy… Good thing there’s a very low chance this could happen to you. ;-)

Mechanical Watch – Bartosz Ciechanowski

Tags: watch, mechanical, science, physics, engineering

Ever wondered about the details of a mechanical watch? Here is an excellent primer. Lots of attention to details.

103 Bits of Advice I Wish I Had Known

Tags: life, wisdom

Really great collection of wisdoms collected through decades. Loved it, some are funny too.

Mending Your Cherished Clothes - Hometown Stories | NHK WORLD-JAPAN On Demand

Tags: culture, japan, craftsmanship

Discovering Kaketsugi, this is a very impressive craft. True labor of love. This is incredible work, feels almost magical. So much patience and attention to details. The amount of analysis which went into it is amazing too.

Bye for now!

Categories: FLOSS Project Planets

Mitubo 0.9: multiple concurrent video downloads

Thu, 2022-05-05 15:16

It will never stop surprising me how easy it is to implement big new features in a QML application! The assumption here is that the C++ part of the application should be well-written: objects should not be overloaded with unrelated functionalities just because it seems faster to code them that way, but one should rather design classes so that each exposes one functionality, and then QML and javascript act as the glue which binds all the parts together.

In a way, QML stands to C++ classes like the POSIX shell stands to command-line tools: a simple language which allows concatenating small units of functionality together to build a powerful program.

Anyway, that was not what I wanted to talk you about today. ☺ Today's post is about MiTubo, whose version 0.9 has been released today:

The big feature in this release is download of audio/video files: I thought, since I'm using yt-dlp (or youtube-dl on Ubuntu Touch) anyway for extracting video streams, why not add an option to let users download the media content? This turned out to be easier than expected, so if you were looking for a graphical frontend to the YouTube downloader, well, now MiTubo is an option you could try.

Categories: FLOSS Project Planets

Qt Speech coming to Qt 6.4

Thu, 2022-05-05 09:00

Over the last couple of months we have ported the text-to-speech functionality in the Qt Speech module over to Qt 6, and it will be part of the Qt 6.4 release later in 2022.

Categories: FLOSS Project Planets


Thu, 2022-05-05 07:27

I’ve finally gotten annoyed enough with inotify failing randomly, because of resource exhaustion, that I’ve built a tiny app to deal with it.

Introducing kde-inotify-survey.

It features a CLI to inspect the inotify state, as well as a kded to warn and help with bumping the maximums. Assuming it turns out amazing for others I hope to progress it to kdereview soon.

Categories: FLOSS Project Planets

KDE Gears 22.04 and Plasma 5.24.5 for Debian

Thu, 2022-05-05 01:37

I have updated my OBS builds to contain the new KDE Gears 22.04 as well as the last point release of KDE Plasma 5.24.5.

As usual, the packages are provided via my OBS builds. If you have used my packages till now, then you only need to change the apps2112 line to read apps2204. To give full details, I repeat (and update) instructions for all here: First of all, you need to add my OBS key say in /etc/apt/trusted.gpg.d/obs-npreining.asc and add a file /etc/apt/sources.lists.d/obs-npreining-kde.list, containing the following lines, replacing the DISTRIBUTION part with one of Debian_11 (for Bullseye), Debian_Testing, or Debian_Unstable:

deb ./ deb ./ deb ./ deb ./ deb ./

Some programs in the other group have been recompiled against the Gears 22.04 libraries.


PS: Considering that I don’t have a user-facing Debian computer anymore, all these packages are only tested by third parties and not by myself. Be aware!

PPS: Funny to read the Debian Social Contract, Point 4. Our priorities are our users and free software, obviously I care more about my users than most of the oligarchs in Debian.

Categories: FLOSS Project Planets