Skip to content

Thursday, 4 August 2022

KIO Admin 🔗

Harald Sitter apachelogger 19:57 +00:00

I’ve gotten annoyed with the inability to manage system files so I’ve made a KIO worker that enables Dolphin to view and edit files as root.

This is dolphin viewing the system root with administrative access.

The way this works is actually fairly exciting. It’s pulling off worker chaining: The admin worker itself contains gloriously little logic, all it does is translate all worker calls to dbus calls, and those dbus calls go out to a privileged polkit helper. The polkit helper then translates the URIs from admin:///foo to file:///foo and uses the regular KIO API to recreate the request in root-scope. KIO then, behind the scenes, acts just like it would in dolphin proper, using the existing file worker code to execute the file operations.

The advantages are amazing! It’s fairly little actual code (albeit a lot of boilerplate). Since it’s an ordinary worker on the Dolphin side we can expect all file operations to just work™ because really admin:// is just like trash:// or desktop://. Because ultimately the file worker is actually in charge of doing the work, all things are generally expected to work (it’s the same code that powers regular file operations).

Disadvantageously it’s a fair large portal into root-scope, meaning the worker should really only be used in trusted environments (e.g. with only sandboxed applications on the system ;)). Even with polkit guarding the entrance, once you have given permissions you have to trust the application (e.g. dolphin) to not get exploited.

“But why a dedicated worker instead of integrated polkit support in the file worker?” Why, I’m glad you asked! Integrated polkit support sounds simple but is really rocket science. For example there is currently no good architectural way to “catch” operations that had gone wrong – you try to copy a file to `/srv` and that fails with 🤖PERMISSION DENIED🤖 but there is no consistent way to then go “well, let’s retry this entire operation with privileges then” so without huge code refactoring first, we’d end up tucking fallback logic onto every which error scenario… it’s messy and also easy to miss or mess up edge cases. There are also user experience problems. You’d not want to have every internal operation require dedicated permission, so you kind of have to bundle them up and then request permission for the bundle; but how do you know when a bundle is complete? It’s really frightfully complicated.

In conclusion admin:// is awesome today. Maybe one day integrated polkit will also be awesome.

Reviews and testing appreciated (mind the readme – this currently wants some patching elsewhere in the stack).

The process of selecting the new KDE Goals is ongoing, and after finishing the submission stage we now have 11 proposals.

As you might see in the workboard, they are in the “Not ready for voting” column. This is because even though they have successfully been created according to the template, there is still much to do before the voting starts.

Right now we are in the Refinement stage, which lasts until August 27th. But what is the purpose of this stage?

The point is to shape each proposal into its best possible version. This is the moment to work on the proposal with a larger audience, seek feedback and gather people that would be interested in participating in the Goal.

Konqi is ready to work on stuff.

I encourage everyone in the community – newcomers and veterans – to look through the proposals and voice your opinions. If you find a proposal that you like and needs some work, be sure to suggest changes. You can help refine any number of proposals. If you want to show support for a Goal proposal in a visible way, each entry should have a “Interest” section at the bottom – you can add your name there.

Some things to consider when refining the Goals:

  • The name of the Goal should be attractive, not very long, and clearly state what is it about. It will be easier to vote for a Goal that has clear steps of how it will be achieved. The more concrete plan is formulated, the better it will look.
  • Ambitious Goals are good, but keep them in the realm of possibility. A selected Goal will be in focus for the community for ~2 years, the community expects major parts of the Goal to be completed in that time AND visible progress to be made on an ongoing basis.
  • And of course, the Goal needs to serve the KDE community :)

With all of that in mind, I again encourage you to look at the current proposals and start refining!

Today we’re releasing the first release candidate for Krita 5.1!

For the full list, check out the work-in-progress full release notes!

Or check out Wojtek Trybus’ release video:


Krita is a free and open source project. Please consider supporting the project by joining the Krita Dev Fund, donations or by buying training videos! With your support, we can keep the core team working on Krita full-time.

Warning: beta 1 had a bug where brush presets were saved incorrectly, leading to crashes when trying to load those presets in other versions of Krita. Here is a Python script that can fix those presets.

Since the second beta, the following bugs have been fixed:

  • Several issues with renaming existing and system tags for resources have resolved. BUG:453831
  • Python: make it possible to get all pattern resources.
  • Fix a slowdown when attaching a dynamic sensor to the ration option in the brush preset editor. BUG:456668
  • Fix scaling of the colorspace selector when display scaling. BUG:456929
  • Fix a memory leak in the storyboard docker. BUG:456998
  • Fix a memory leak in the tile engine. BUG:456998
  • Make the Alpha mode the default generator for the Halftone filter.
  • Improve handling of switching between exporting just the frames or just the video for an animation. BUG:443105
  • Clean up files when exporting an animation to frames is canceled. BUG:443105
  • Fix the Elliptic are to Bezier curve function in SVG so certain files can be loaded without Krita running out of memory. BUG:456922, BUG:439145
  • Fix issues handling gradient fills for vector objects. BUG:456807
  • Make sure the mimetype selector Ok and Cancel buttons can be translated. BUG:448343
  • Fix a crash when cloning a document through the scripting API. BUG:457080
  • Reset the file path when creating a copy of an existing image. BUG:457081
  • Fix a crash when copy-pasting a group with vector layers. BUG:457154
  • Fix saving a image with a text object to PSD. BUG:455988
  • Fix a crash when undoing creating a text shape. BUG:457125
  • Fix a crash when loading a thumbnail for a PSD file with embedded resources. BUG:457123
  • Improve the performance of creating a thumbnail from a PSD file for the recent files list. BUG:456907
  • Fix loading PSD files with embedded patterns.
  • Fix undeleting tags that have been removed. BUG:440337
  • Make it possible to open some invalid PSD files. BUG:444844
  • Fix positioning of layers returned from the G’Mic plugin. BUG:456950
  • Fix loading JPEG-XL images created by Substance Designer. BUG:456738
  • Fix showing the alpha channel in the color picker tool options widget.
  • Fix a crash when there is a corrupt in image on the clipboard. BUG:456778
  • Fix the positioning when pasting multiple reference images. BUG:456382
  • Fix Krita hanging when double-clicking too fast with the contiguous selection tool. BUG:450577
  • Fix updating the current palette when selecting a color with the color picker. BUG:455203
  • Improve the calculation of the brush speed sensor. BUG:453401



If you’re using the portable zip files, just open the zip file in Explorer and drag the folder somewhere convenient, then double-click on the krita icon in the folder. This will not impact an installed version of Krita, though it will share your settings and custom resources with your regular installed version of Krita. For reporting crashes, also get the debug symbols folder.

Note that we are not making 32 bits Windows builds anymore.


The separate gmic-qt appimage is no longer needed.

(If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)


Note: if you use macOS Sierra or High Sierra, please check this video to learn how to enable starting developer-signed binaries, instead of just Apple Store binaries.


Due to changes in Google’s SDK requirements, we could not make 5.1.0-RC1 APK’s this time. They will return in the final release.

Source code

The post First Release Candidate of Krita 5.1.0 is out appeared first on Krita.

Tuesday, 2 August 2022

Tuesday, 2 August 2022. Today KDE releases a bugfix update to KDE Plasma 5, versioned 5.25.4.

Plasma 5.25 was released in June 2022 with many feature refinements and new modules to complete the desktop experience.

This release adds three weeks' worth of new translations and fixes from KDE's contributors. The bugfixes are typically small but important and include:

  • KWin Effects/colorpicker: Fix picking colors. Commit. Fixes bug #454974
  • Plasma Workspace: Fix unable to remove manually added wallpaper. Commit. Fixes bug #457019
  • Update battery notifications if they remain open. Commit.
View full changelog

Sunday, 31 July 2022

Second issue about the progress on rolisteam.

1. Mindmap

When I wrote down a story for a TTRPG game, I always find useful to draw an interaction diagram. It’s the best way to get an overview of the story really quickly. First, it was on blocknotes, then I wish for a better tool and I designed it.

For a overnight game, this is how a mindmap looks: image

Now, we decided to add this rmindmap into rolisteam. The original tool has received several versions and implementation about diagram style and technology.

Adding QML mindmap into rolisteam

Let’s talk about technical aspect here. The main difference between the stand-alone version and the mindmap inside rolisteam is that in rolisteam, some components have to follow some APi.


Basically, MediaControllerBase is the low-level api that every media controller shares. You share an image on rolisteam, there is an ImageController which extends from MediaControllerBase. And it is the case for every media: Charactersheet, virtual map, Notes…

MediaControllerBase stores all data required for identifying the media (Uuid, name…) and it also stored data to describe the permission context: the owner, the gamemaster, and does this controller is a remote version or the original one.

Then, you have the MindMapControllerBase which provided the mindmap API, such as adding nodes, links, packages, remove them, manage the selection and so on. This code is mainly from the original stand-alone software rmindmap.

Then, the last layer: MindMapController. This class takes in charge any specific behaviour or feature for mindmap into rolisteam. The mindmap is the second media to have a permission selector. Users will be able to share in read-only mode or read-write mode to everyone or to some selected people.


  • Add node
  • Customize node: text, description, tags and style
  • Add picture to node (drag and drop or contextual menu)
  • Default style
  • Editable link label
  • (Activate/Disactive) Automatic spacing
  • Add Packages
  • Dark mode
  • Realtime small view, the visible part on the mindmap is marked with a blue rectangle
  • Export in png
  • hide/show link label
  • Search for node based on tags, name or description
  • Show/Hide children node
  • Reparenting
  • Add link
  • Undo/Redo
  • Zoom in/out
  • Automatic save

Demo: From nothing


Demo: The big one


2. Image in instant messaging

We implement a small feature on the instant messaging. If you copy/paste a link to image. The url is replaced by the image.


Other urls (to website or other kind of format), the link is clickable.

3. Upnp class

Some users have difficulties to configure their network device at home to host games.
Then, we create a simple QObject to open network port and forward it to the rolisteam server. In rolisteam, the object will only be used on server side.

You can find the implementation here It is already integrated into rolisteam. Some improvements can be done, of course. But it works on our side. Feel free to test it on your side and give us feedback.
There is a unit test to run. The unit test does exactly what we are doing in rolisteam.

4. Translation scripts for KDE

As you may know, rolisteam is now part of KDE. We are trying to enjoy that new status. One way to do it, it’s to change the way rolisteam is translated. The KDE project has huge translation team and they are really efficient.
On project side, when you want your application to be translated. You have to provide a script that extract all texts. We made this script for DiceParser, and it is now ready for rolisteam.

5. Work for August

  • Finish Mindmap
  • keep working on Vectorial map
  • See network status for mindmap and vectorial map

Porting a Tiling Window Manager Extenstion to C++ (Bismuth): Part-2 (getting closest relative window)

Hi everyone! In this blog, I will be discussing the algorithm used in Bismuth to find the closest relative window to be focused for focusWindowByDirection event. If you haven’t read the previous blog, make sure to give it a read here.

Recap from the previous blog

Let’s start with a quick recap though, in the previous blog, we discussed:

focusWindowByDirection requires the following information:

  • direction (from the user) - can be one of: right, left, top/up, bottom/down.
  • activeWindow (from the current session) - this is needed since focusWindowByDirection event is a relative event to your current focused window.
  • Neighbor window candidates (neighborCandidates) to your current window (activeWindow) and the given direction (direction).
// declaration
std::vector<Window> Engine::getNeighborCandidates(const FocusDirection &direction, const Window &basisWindow);

// use
std::vector<Window> neighborCandidates = getNeighborCandidates(direction, basisWindow);
  • From these neighbor candidates (neighborCandidates), we will now find the closest relative window corner. To me, it was tricky to understand at first, so we’ll be discussing this in detail over in the later sections.
  • Once we know the closest relative window corner, we’ll try to find the window which satisfies the corner condition.
  • If there were multiple found, we’ll return the first one based on the time-stamp (last used)

Understanding the scenario

I want to start off with a visual, took me some time to draw it, but in case it doesn’t look good, I’m sorry! My drawing teacher in the high school tried his best, but…

Above image is visual of a tiling window layout where there are in total 5 windows opened (just for imagination, no sane person would open these many windows on a 24 inch monitor… xD): A, B, C, D, E, where as mentioned in the figure above, E is the active window and we are trying to focus UP. A few notes to take from the figure:

  1. A, B, C, D windows are of same height and width w and h. We’ll use this information later.
  2. E window is the active window with width: 2 * w and height: h.
  3. We are trying to focus UP.

Getting Closest Relative Window Corner

In the previous blog, we had covered getNeighborCandidates, the output here would be windows: A, B, C, D. The order will not matter here for understanding, so don’t worry about that.

The next steps in the code include:

int closestRelativeWindowCorner = getClosestRelativeWindowCorner(direction, neighborCandidates);

auto closestWindows = getClosestRelativeWindow(direction, neighborCandidates, getClosestRelativeWindow);

return most_recently_used(closestWindows);

I didn’t add comments here, because we’ll be going through these 2 magic functions below. Let’s start with getClosestRelativeWindowCorner. The source code for the definition of this function is:

int Engine::getClosestRelativeWindowCorner(const Engine::FocusDirection &direction, const std::vector<Window> &neighbors)
    return std::reduce(neighbors.cbegin(),
                       /* initial value */ direction == Engine::FocusDirection::Up || direction == Engine::FocusDirection::Left ? 0 : INT_MAX,
                       [&](int prevValue, const Window &window) {
                           switch (direction) {
                           case Engine::FocusDirection::Up:
                               return std::max(window.geometry().bottom(), prevValue);
                           case Engine::FocusDirection::Down:
                               return std::min(window.geometry().y(), prevValue);
                           case Engine::FocusDirection::Left:
                               return std::max(window.geometry().right(), prevValue);
                           case Engine::FocusDirection::Right:
                               return std::min(window.geometry().x(), prevValue);

Don’t worry about the code if it confuses you, keep in mind that we have the direction as Engine::FocusDirection::Up, and neighbors as {A, B, C, D}. This function gets you the closest window corner relative to the active window or the basis window. How would you do that? Well, it will depend on the direction.

If the direction is Up or Down –> you should compare the y coordinate. If the direction is Left or Right –> you should compare the x coordinate.

Now remember the mathematics lectures you had way back in the high school, if you wanna focus up, which vertex do you really care about? Keep your focus on the window C and E for once, the comparison should definitely be with the bottom right’s y coordinate, right? That’s what we do here:

case Engine::FocusDirection::Up: 
  return std::max(window.geometry().bottom(), prevValue);

A quick look at bottom() source code in qrect.h file:

Q_DECL_CONSTEXPR inline QRect::bottom() const noexcept { return y2; }

Where y2 is the bottom right’s y coordinate. Since we are going up, and anything above the basis window should have y value < basis window’s y value. (The top left of any screen is considered to be (0, 0) in this blog). Hence we set the initial value as 0. If we had to go down, we’ll set it to INT_MAX as for anything below the basis window, we’ll use std::min and hence INT_MAX will fade away with each neighbor window.

Anyways, enough of theory, so what will be the output of this function for our scenario? Well, this function will give us y_C + h (which is equal to y_D + h, so any of them is fine). Now, we’ll go ahead to the next function.

Getting Closest Relative Window

std::vector<Window> getClosestRelativeWindow(const Engine::FocusDirection &direction, const std::vector<Window> &windowArray, const int &closestPoint)
    std::vector<Window> result;
    std::copy_if(windowArray.cbegin(), windowArray.cend(), result.begin(), [&](const Window &window) {
        switch (direction) {
        case Engine::FocusDirection::Up:
            return window.geometry().bottom() > closestPoint - 5;
        case Engine::FocusDirection::Down:
            return window.geometry().y() < closestPoint + 5;
        case Engine::FocusDirection::Left:
            return window.geometry().right() > closestPoint - 5;
        case Engine::FocusDirection::Right:
            return window.geometry().x() < closestPoint + 5;
    return result;

Again, remember, we have direction as Engine::FocusDirection::Up, windowArray as {A, B, C, D}, and closestPoint as y_C + h value.

This function only exists to give you all the windows which are close enough to the closestPoint. The output out of this function will be windows C, D (reminder: E is the basis or active window).

Some will wonder why do we have two functions: getClosestRelativeWindowCorner, and getClosestRelativeWindow? And why this -5, +5? Unfortunately, it’s possible that some windows aren’t tiled properly, see this issue. I’ve attached the screenshot: (credits to the author)

Hence we can’t be too strict here. I personally believe this number +/- 5 should be tinkered better and not hard-coded, but that’s for later.

So from A, B, C, D being the neighbor candidates, we have C, D as the final closest windows to the basis window (E). Now which one to choose? That’s where we’ll have to store the timestamps for each window. And this timestamp should record the last time it was used or accessed. We just get the most recently used out of these windows, and I’ll be discussing in the future blogs. I think we discussed a lot today. So that should be it…


I don’t want to shy away from thanking the main maintainer of Bismuth, gikari who has worked pro-actively on Bismuth. Of course, the credits should also go to krohnkite for the hard work they put in.

In case anyone has a feedback or suggestion, please leave a comment on this blog. I wish everyone good health and success. Thanks for reading <3

Saturday, 30 July 2022

The Skrooge Team announces the release 2.28.0 version of its popular Personal Finances Manager based on KDE Frameworks


  • Correction: update gengetopt dependency in flatpak
  • Correction bug 452529: skrooge flatpak is using org.kde.Platform//5.15 which is end-of-life
  • Correction bug 452531: Skrooge flatpak indicates old version
  • Correction: document the settings icon in a table's header to bring up its context menu
  • Correction bug 446352: field pop-ups located weirdly, "##WARNING: Wayland does not support QWindow::requestActivate()", sometimes hangs
  • Correction bug 452529: skrooge flatpak is using org.kde.Platform//5.15 which is end-of-life
  • Correction bug 452695: Skrooge report (Line) having issues with values above several millions
  • Feature: The "Debug" page allows to execute multi sql orders
  • Feature: Import .sta file as MT940

Get it, Try it, Love it...

Grab Skrooge from your distro's packaging system. If it is not yet included in repositories, go get it from our website, and bug your favorite distro for inclusion.

Get Involved

To enhance Skrooge, we need you ! There are many ways you can help us:

  • Submit bug reports
  • Discuss on the KDE forum
  • Contact us, give us your ideas, explain us where we can improve...
  • Can you design good interfaces ? Can you code ? Have webmaster skills ? Are you a billionaire looking for a worthy investment ? We will be very pleased in welcoming you in the skrooge team, contact us !


KStars v3.6.0 is released on 2022.07.30 for MacOS, Linux, and Windows. It's a bi-monthly bugfix release with a couple of exciting features.

Linear 1 Pass Algorithm

John Evans contributed a new Focus algorithm: The Linear 1 Pass Algorithm. When using this algorithm, Ekos initially performs like the Linear algorithm in establishing the first pass V-Curve and fitting a curve to it to find the solution. Then, however, it moves directly to the calculated minimum. Key features include:

  • The algorithm compensates for focuser backlash, providing that backlash is consistent.

  • The algorithm is fast, taking 1 pass to identify optimum focus.

  • The algorithm uses more sophisticated curve fitting to pinpoint the optimum focus position.

  • The algorithm is highly configurable with user control over many parameters like step size and number of steps.

Early tests by various users shows very promising and stable results

Polar-alignment V3

Hy Murveit introduced a new Polar Alignment method based of plate solving. The original polar-alignment error measurement scheme has not changed. The user interface has changed slightly--different messages and a new LED display to indicate progress.

The original polar-alignment refresh/correction method still exists (if you choose the MoveStar or MoveStar & Cal Err refresh methods).

A new polar-alignment refresh/correction method is provided called PlateSolve. It allows for corrections of larger polar-misalignment in a single pass, does not depend on the image display, and may be more reliable if your plate solving is working well.

A new alternative to MoveStar is the PlateSolve method. This can polar align mounts with larger alignment errors in a single procedure. A similar triangle is displayed on the image display, but it is not central to this scheme. 

Rather the user should concentrate on the Updated Error line at the bottom of the display, and attempt to zero the Altitude and Azimuth errors. Also, arrows display the direction the mount needs to move to reduce error.

The method works by plate-solving images as they are captured, and then estimating the user's knob-adjustments from the plate-solve solutions. Note that, since knobs may be moved during exposures, some images may have large star trails and plate solves may fail. Be patient and allow the system to capture a clean image before relying on the error estimate. 

Image ROI Statistics

Madhav Prabhu made his first contribution to KStars by adding Region-Of-Interest (ROI) selection in FITS viewer where users may view statistics for a particular region of the image. The stats include average, median, and standard deviation.

You can select from existing probes of varying sizes (50x50, 100x100..etc), or you can simply hold down the Shift key and drag the mouse to create your own rectangle.

Profile Scripts

For complex equipment profile that have inter-dependencies requiring script execution or programmable delays, the new Script Profile edit provides complete control over the driver startup sequence.

You may define a Pre-Delay and Pre-Script before a driver is executed (e.g. script to turn on the observatory electricity), and define a Post driver delay and script if desired. For some drivers like Pegasus Ultimate Power Box, it is often desirable to start this driver before other drivers so that all configuration is loaded.

Geographic Map Update

Ed Lee made his first contribution to KStars by replacing the old geographic map from a new high quality version from NASA. This should play more nicely on larger monitors and high DPI displays.

Misc. Updates

Small but important quality of life improvements to KStars & Ekos.
  • Hy Murveit Show number of clipped pixels on fitsviewer status bar if show-clipping is enabled
  • Akarsh Simha Improve the manual focus dialog for the SkyMap
  • Sophie Taylor Correct nomenclature for Linear1 focus algorithm with "R2" -> "R²", and add a default and minimum value for R² limit
  • Akarsh Simha Further improvements to Add Catalog Object UI, including auto-filling data from text.
  • Sophie Taylor Improve tooltips for GPG expert settings
  • Akarsh Simha Various fixes and improvements related to DSO catalogs and visibility.
  • Akarsh Simha Refactor `DmsBox` widget and improve the Add Catalog Object form.

This is a maintenance release as part of the ongoing effort to support our users and fix bugs and annoyances. If you think you can support the project with some code changes or your artistic or writing talent, please take a look at the some low hanging fruits at the KMyMoney junior job list. Any contribution is welcome.

Despite the ongoing permanent testing we understand that some bugs may have slipped past our best efforts. If you find one of them, please forgive us, and be sure to report it, either to the mailing list or on

The details


  • 432380 Appimage unable to print reports


  • 426161 Duplicating an investment transaction also duplicates a matched but not accepted transaction in the brokerage account with original not the new date on the matched transaction
  • 447025 Calculation of the balance is incorrect for future balances


  • 445458 Investment Cap Gains by Account (Customized) crashes with my dataset. Changing the date of one ledger entry fixes the crash.
  • 450016 Attempting KMyMoney 5.0.8 “Currencies” Maintenance, Application Crash
  • 451677 crashes on new category with a double colon


  • 223708 Closed accounts are not hidden in accounts/categories view
  • 411272 Not saving changes to Shortcuts
  • 424303 Export report as csv file gives a html file
  • 425333 no pre-defined account templates on a mac
  • 428156 OFX import goes to the wrong account
  • 435866 No ledger icon in the pane of the left side
  • 439287 Home view is missing styling
  • 439722 Equities are shown with currencies in new account dialog
  • 439819 Issue with changing credit card limits
  • 439861 Rounding error on investment transactions
  • 440060 Icons are missing on Linux if Breeze icon theme shipped by the bistro is older than 5.81
  • 440111 Tags/Payees Double Enter
  • 440476 Can not update stock price manually
  • 440500 Stock wizard shows online source that no longer exist
  • 440681 Currency list not sorted with locale awareness in the new account wizard
  • 440692 When importing OFX, the OK and Skip buttons are reversed
  • 440695 Unable to inspect the Splits when account is closed.
  • 441292 Impossible to paste into calculator widget
  • 443208 Build failure with aqbanking 6.3.2
  • 444414 Transaction notes are not imported from paypal account
  • 445472 Stock split transactions can cause rounding problems
  • 446990 Wayland: Tooltip on date input fields steals focus, prevents entering data
  • 451891 Setting the payee matching to exact name is not persistent
  • 452068 kmymoney complains about “GPG no secure keyring found”
  • 452497 Scheduled transactions: “Next due date”, “Number remaining” and “Date of final” do not always update in step
  • 452616 Missing transaction information
  • 452720 Provide feature to rename existing loan accounts
  • 452918 Payee > Account Numbers > IBAN does not accept pasted content with a space at the start
  • 456520 OFX import broken upstream


  • 440736 In “New Account” wizard, Enter key does not work on “Parent account” page
  • 441296 Fields in Exchange Rate/Price Editor misaligned
  • 441937 Default cash flow report: Name does not match date range
  • 448013 Unresponsive UI elements in “New File Setup” > “Select Accounts”
  • 452863 New file setup wizard: UK VAT Accounts produces “invalid top-level account type” error


  • 399685 add match strings as well as name from deleted payee to new payee
  • 424377 Change default matching behavior for new payees to “match on exact payee name”
  • 440586 When exporting a report, the file name (suggested) takes the report name
  • 441581 When “Amount” at ledgers get the focus by click, select the entire value
  • 444262 Date picker, frequency and process schedule at last day of the month should interact
  • 447480 Allow currencies to be divisible by more than ten decimal places
  • 450965 Please add Functionality to Scheduled Transactions
  • 453922 Decimal and thousands separators in ordinate axis labels are missing

A complete description of all changes can be found in the ChangeLog.

Since the last update on KDE Itinerary we have been working further towards the upcoming 22.08 feature release. Here are some of the highlights.

New Features

Calendar integration

After the necessary foundational work has been finished, Itinerary now has a completely new integration with the corresponding system calendar on Android and Linux.

So far it was only possible to import events created by KMail’s itinerary plugin from the Android calendar. This is now not only also possible on Linux, but is also no longer restricted to those specific events.

Instead, events that the travel document extractor recognizes as e.g. train trip due to being provided by an iCal file from the corresponding train operator or booking agent can now also be imported. You can also import arbitrary events as such.

Events are also no longer imported automatically and from all calendars, but you can now select which calendar to import from, and which events exactly to import. This also avoids ending up with trips in your timeline from other people’s shared calendars.

Screenshot of KDE Itinerary's calendar import page.
Calendar import page recognizing transport elements and allowing individual selection.

On top of that, Itinerary now also allows to export individual elements to a calendar.

Passes & Programs

The “Passes & Programs” view introduced last time for managing flatrate tickets or discount program membership cards that aren’t limited to a specific element in the timeline received significant extensions:

  • Generic UIC 918.3 tickets and VDV e-tickets are now supported as well (this includes the German 9-Euro-Ticket for example).
  • Tickets/passes now have information about their validity time span, expired ones are grouped at the bottom of the view.
  • Tickets/passes imported multiple times are automatically merged together, and importing documents that contain both generic and time-bound tickets is now supported as well.
  • More variants of the SNCF discount program cards are recognized.
Screenshot of KDE Itinerary's passes and programs page, grouping entries by validity.
Passes, tickets and discount program cards grouped by validity.

Manually added train/bus trips

The ability to manually add train or bus trips from online journey queries is now finally available by default on all platforms. This was presented here some time ago already, but was blocked on a proper release of the Kirigami Addons module to far.

This is still not really solved, but we now ship a bundled copy of the relevant components as part of Itinerary. That isn’t elegant nor the desired long-term state, but it at least unblocks this feature for now.

Screenshot of KDE Itinerary's train trip search page.
Train trip search page.

Akademy 2022

KDE Akademy 2022 is coming up, for the first time since 2019 not as a purely online event. That of course provides ample opportunity for field-testing KDE Itinerary :)

If you are looking for starting Akademy early, eco-friendly travel options and/or contributing complex Itinerary test cases, the #akademy-by-train Matrix channel might be of interest to you.

A number of fixes for the travel document extractor and travel data processing have already come out of this.

Infrastructure Work

KI18n catalog loading on Android

The translation catalog handling on Android had a long-standing issue in KI18n, with the catalog files being stored in the asset section of the APK package, and libintl-lite expecting them in the local file system.

This required KI18n to copy catalogs on demand out of the APK asset store into the file system, which is slow, costs precious disk space and caused problems with catalogs not being properly updated.

With KDE Frameworks 5.95 this has finally been fixed, for the majority of Android devices at least. If the Android system is sufficiently new (API level >= 23), catalog files are now consumed directly from the asset store (MR).

Polar day/night support for KWeatherCore and KHolidays

The KHolidays framework provides among other things the math to calculate the sun position for any given time and location. This is used for example to determine whether to use the day or night icons for weather forecasts, or for computing opening hours.

This works fine, as long as there actually is a sunrise and a sunset on the day in question, and for most people that assumption always holds. Not so however once you get very far north or south, towards the polar regions.

For KDE Frameworks 5.96 KHolidays has been fixed to no longer report misleading values during polar day/night conditions, and with 5.97 it will get new API to check for those cases specifically. KWeatherCore makes use of this already to ensure showing correct weather icons.

Beyond Itinerary, this might also be of interest for the Plasma night color feature for example.

Qt 6

If you are following Planet KDE you are probably aware of the ongoing efforts to prepare for the transition to Qt 6 all over KDE’s software stack, and Itinerary isn’t exempt from that.

All of Itinerary’s dependencies are meanwhile fully functional with Qt 6, and there’s mainly two larger remaining issues affecting Itinerary itself:

  • Android APKs don’t build with Qt 6 and ECM yet, due to a PIE vs PIC mix-up.
  • The map view components provided by Qt Location are not yet available again in Qt 6.

Fixes & Improvements

Travel document extractor

  • We now attempt to merge “triangular” trip data, ie. data with and without intermediate stops included, as far as that is detected with sufficient certainty. This is necessary as some operators provide information with different levels of detail depending on the medium (e.g. PDF vs. iCal).
  • Direct barcode extraction support for Renfe and Trenitalia tickets.
  • Data extraction from iCal events for Trainline, DB, GWR, Trenitalia and Swiss.
  • New data extractors for ZSSK and local transport tickets produced by eos.uptrade.
  • Improved data extractors for BVG, DB, MÁV, ÖBB, SNCF, and standardized European RCT2 tickets.

Public transport data

  • Improved support for GBFS v2.1, including docked vehicle details, vehicle type names and more address properties.
  • Handle some common deviations from the GBFS standard, and fixed/reported some standard violations in the corresponding upstream projects.
  • Display more GBFS vehicle details in the station map.
  • Avoid monorail systems being mis-detected as regular railways and thus confusing the platform detection logic. Particularly useful in cities with exotic means of transportation.

Itinerary app

  • Correctly ignore unavailable documents when showing the amount of documents attached to a reservation (bug 456510).
  • Select the ticket of the current user by default in case of multi-traveller reservations.
  • Only add transfers automatically if there is sufficient certainty that the there is a location change. This fixes spurious transfers being added between direct connections in some cases with location name variations.
  • Consider non-location change elements when determining location as well (bug 455083). This provides more correct results for e.g. weather and public holiday information when the only element in the timeline is a hotel reservation for a different location.
  • When adding train trips manually, consider previous elements when determining the default departure time.
  • Apply the data extraction post-processing to manually added train trips as well. This fills in possibly missing data such as the country or timezone of a location, which various other features rely on.
  • Improved confirmation dialogs.
  • Fixed date input issues on desktop and mobile.

How you can help

Feedback and travel document samples are very much welcome, and there are plenty of other things that can be done without traveling as well. The KDE Itinerary workboard or the more specialized indoor map workboard show what’s on the todo list, and are a good place for collecting new ideas. For questions and suggestions, please feel free to join us on the KDE PIM mailing list or in the #kontact channel on Matrix.