November 09, 2019

If you are building Qt-based Android applications that need network access, you need to take care of bundling OpenSSL yourself. That has always been the case, however with Qt 5.13.1 (or later), there’s a crucial change that might require you to update your OpenSSL bundling. Users of the KDE Android SDK Docker image are luckily not affected by this, but if you have a manual setup this is likely relevant for you.

The Problems

There’s several reasons why the OpenSSL handling in Qt in general and for Qt on Android in particular is a bit special:

  • OpenSSL is a hard dependency for Qt networking. Such dependencies are usually linked against by Qt libraries. While possible for OpenSSL too, the default build option is to dlopen it at runtime, and that’s also what the official Qt binaries do. This has the side-effect or moving the error handling of missing or wrong OpenSSL libraries to much later in the applications lifetime. (This is where the custom-built Qt in the KDE Android SDK differs, that treats OpenSSL as a linked dependency).

  • OpenSSL is not bundled with Qt, unlike most other hard dependencies. Qt does this in source for some dependencies, as well as for some binaries in the official installer. OpenSSL is the exception due to license compatibility concerns, which is also the reason for the dlopen hack.

  • Different OpenSSL versions aren’t entirely ABI compatible as far as Qt’s needs go, depending on build options etc. Qt might expect a newer version than is available. That becomes an issue in combination with the following point.

  • (Some?) Android systems ship OpenSSL, depending on the API level in different versions, not all of them usable, but nevertheless being visible when searching for libraries.

Until Qt 5.13.0 all you needed to do was making sure regularly built OpenSSL libraries were in the APK package, either by building that yourself, or by taking pre-built binaries from a sufficiently trusted source.^

The Change

In order to avoid the interference from incompatible OpenSSL provided by Android, Qt 5.13.1 changed what it expects to be the name of the OpenSSL libraries when dlopen’ing them. Obviously this breaks existing setups if you don’t adapt your OpenSSL build accordingly. And annoyingly that breakage will only show up at runtime in form of failing network access.

Unfortunately the Qt 5.13.1 release notes don’t seem to mention the implications of this change, so a bit of digging through the code was required. The relevant change is this commit and it provides an indication on how we need to adjust the OpenSSL libraries, namely by adding a “_1_1” suffix before the file extension. Adding SHLIB_EXT=1_1.so as make argument to the OpenSSL build accomplishes this for example. If you are deploying OpenSSL to the APK by just linking your application to it, that’s already all that needs to be changed.

Hopefully this saves someone from spending needless time on debugging this again :)


Dear digiKam fans and users, We received a lot of excellent user feedback after publishing the 4th digiKam 6 release in September 2019. We are now proud to briefly announce the new digiKam 6.4.0, a maintenance version which consolidates this feedback and acts as an important phase of this 3-year-old project. The Plugins Interface “DPlugins” Extended Again With 6.1.0, digiKam project has introduced the new DPlugins interface to customize and extend the application.


Another month, another revision of the digiKam Recipes book. This version brings the following new content: The How digiKam works chapter provides an overview of digiKam’s achitecture The Export and import keyboard shortcuts scheme section explains how to export and import customized keyboard shortcuts profiles. All digiKam Recipes readers will receive the updated version of the book automatically and free of charge. The digiKam Recipes book is available from Google Play Store and Gumroad.


November 08, 2019

KStars v3.3.7 is released for Windows, MacOS and Linux. This late autumn release packs a lot of new features and fixes across the board.

ASTAP integration


ASTAP is an astrometric plate solver, stacking of images, photometry, and FITS Viewer application available for Windows, MacOS, and Linux on multiple architectures.

KStars included support for solving via ASTAP in the Align module in addition to the existing astrometry.net solver. ASTAP employs a different method to solve images making it extremely fast  while at the same time requiring a smaller star catalog compared to other astrometric solvers.

You need to download and install the G17 Star Catalog for ASTAP to work locally.

ASTAP Solver

The error reporting was improved to show the overall error in arcsec. Furthermore, the Align module initial FOV is calculated from the camera and telescope parameters (no longer default to 0x0'). This make the initial solve with a wider search radius faster compared to a blind solve. Once the exact FOV is measured, the search radius is reset to the default value to expedite subsequent searches.

Observatory Weather


Wolfgang Reissenberger continued his outstanding work on the observatory module by adding a dedicated weather widget with live plotting for each parameter.


FITS Enhancements


Hy Murveit contributed further improvements to the FITS loading mechanism which resulted in speed ups during sequence capturing.

When capturing images, previously once the capture was complete, images were written to disk, then read back, then displayed in the fits viewer (if enabled), and finally the next image could be captured. This delayed the next capture by a few seconds.

With this change, the FITS data is displayed using (a copy of) the INDI blob sent to INDI::CCD, a memory buffer, and the FITS data is written to disk on a separate thread, which does not block the next capture nor the display of the INDI data.

Focus Module


Eric Dejouhanet Fixed HFR calculation in the FITS Data class, which was accumulating integer instead of double values.

This led to incorrect consolidation of HFR over multiple stars in the focus procedure and incoherent results in full-frame mode.


The UI received an overhaul as well to make the various settings more accessible. Each detected star HFR is now displayed next to it.

Scheduler Updates


Eric Dejouhanet implemented customizable dusk and dawn offsets (D23869). This introduces two new Ekos options, located in the Scheduler option pane. Dusk (resp. dawn) offset will apply a positive or negative hour offset to today's astronomical dusk (resp. dawn) when scheduling observation jobs.
The dawn offset and the pre-dawn offset are cumulative, but the dawn offset allows an earlier or later dawn to be used both while scheduling and executing.

The resulting dusk-to-dawn interval is displayed in the Scheduler UI on the right side of the Twilight checkbox. If the Twilight restriction is checked, the modified dusk and dawn values will be used to schedule the observation job to night time.

If the Twilight restriction is not checked, the observation job will not depend on night time and the modified dusk and dawn will be ineffective in scheduling that job.

The dusk and dawn offsets can be modified from the Ekos Scheduler options, and the night time interval displayed in the Scheduler UI will be updated when applying the changes in that dialog.

Additionally, if the Scheduler is not running, jobs will be re-evaluated to take the new dusk and dawn values into account. However, jobs will only effectively update their schedule if the night time constrain them to do so, not if the night time restriction relaxes.

Guiding & PHD2 improvements


Robert Lancaster improved PHD2 integration with Ekos.

This update is intended to fix several PHD2 problems and provide several PHD2 enhancements.


Fixes an issue where if the user hits the stop button while guiding in the PHD2 interface, then the user restarts guiding from PHD2, Ekos did not pick up the guide state change since no settling occurred and the user didn't click guide in Ekos.
Fixes an issue where the guiding data was not put into the graphs if the user did not enter a focal length into PHD2. Formerly the solution was to put a warning in the Guide log, but users ignored that. Now this tries to set the current CCD, so the backup method can work the way it was intended to work.
  1. Fixes an issue when the user had external guide frames selected, they did not appear in the guide view, and instead loaded in the fits viewer.
  2. Enables the loop and capture buttons for PHD2 along with the corresponding functions to make them work. Works well if the camera is connected to Ekos, also works if its not, but it will not display in Ekos. A message prints to the log letting the user know why.
  3. Disables the binning combo box which was enabled accidentally.
  4. If the user has external guide frames enabled, this enables the tracking box so that the lock position in the image can be reported to the user, and it also enables the user to be able to click to change the lock position for PHD2.
  5. This improves Ekos's ability to recognize the guide camera by using PHD2's report of what guide camera it is using. Then Ekos can use this information to disable or enable the receipt of image frames as well as the option to use the SubFrame checkbox.
  6. Improves the communication about the various options and status for cameras connected to PHD2 and Ekos.
  7. Enables the SubFrame method for PHD2 cameras so that they can switch quickly back and forth between the Guide Star image and full frame external guide frames at the push of a button.
  8. After I cleaned up some of the old and no longer needed methods/code, Ekos now connects to PHD2 much faster.
  9. I added the option for the user to select autostar, or to have PHD2 use the star lock position chosen by the user.
  10. Removes the External Guide Frames option since this makes it obsolete
  11. Saves the subframe option between KStars sessions and sets Ekos to receive External Guide frames or not based on it.
  12. Removes all the setting and unsetting of external blobs for Linguider, which doesn't support INDI cameras anyway, so it was pointless.
Furthermore, the guiding module now shows directional guiding label to help see which directions are affected by the pulses.

Misc Enhancements & Bug Fixes


+ Added download time estimation to the capture module. (D25138)
+ Solved several issues with guiding & dithering in both capture & scheduling. (D25110, D25105)
+ Fixed gain setting in capture module. (D24417)
+ Fixed focus HFR-averaging issue. (D24352)
+ Connect Scheduler sleep timer to Simulation Clock scale change. (D24151)
+ Handling of aborts during parking/unparking of rolloff roofs corrected. (D24064)
+ Hitting a constraint sets a job to IDLE instead of COMPLETE so that it might be restarted later. (D24232)
+ Update OpenNGC to v20191019 (D24896)

LabPlot

The big release this month has been LabPlot 2.7. LabPlot is fast becoming one of KDE's highest profile apps. It is an application for interactive graphing and analysis of scientific data. LabPlot provides an easy way to create, manage and edit plots. It allows you to produce plots based on data from a spreadsheet or on data imported from external files. Plots can be exported to several pixmap and vector graphic formats.

In this release we made the user experience while working with LabPlot easier and more fun. Entering and working with data in spreadsheets is slicker and when reading live data from file sources you can now use a relative path to find a live data source. This allows you to, for example, copy the folder containing the project file together with the data file or files across different folders on your computer without losing the connection to the file or files. In the Project Explorer you can now move top-level objects to different folders via drag & drop.

The data picker, which allows you to digitize data points on images, has had an overhaul in 2.7. The devs have greatly simplified the overall workflow and the process of digitizing data points as you can see in this video.

Check out the Labplot YouTube channel for more videos on using this advanced application.

Bugfixes

Alternative panel Latte Dock got a bugfix release, 0.9.4. It fixes autoloading in some distros such as Manjaro.

KDevelop is on its monthly bugfix release which tidied up CLang support for some distros.

Over 100 apps gets released as part of the KDE Applications bundle which has just had its 19.08.3 bugfix releases and includes:

  • In the video-editor Kdenlive, compositions no longer disappear when reopening a project with locked tracks.
  • Okular's annotation view now shows creation times in local time zone instead of UTC.
  • Keyboard control has been improved in the Spectacle screenshot utility.

Snap Store


Kdenlive Snap

Snaps are one of the new container-based package formats for Linux. KDE has over 50 apps published on the Snap store and ready to be installed on almost any Linux distro. On many Ubuntu flavors and derivatives, they come ready to be used. On others you may need to use your package manager to install snapd first. This is usually as simple as running a command such as sudo dnf install snapd or sudo pacman -S snapd. Most of KDE's Snap packages are built by the KDE neon team on their servers and the aim is to get packaging and building integrated more directly with app's repositories and continuous integration setups. This means they are updated more frequently and the moment changes are made so you always get the latest and greatest features and fixes.

New this month in the Snap store is KDE's video editor, Kdenlive.


Coming Up


KTrip

We have a couple of nice progressions towards stable releases from KDE apps. First, the mobile journey search app KTrip has moved into kdereview, meaning the authors want it checked over for sanity before making a stable release. In a first for KDE developer Nicolas Fella, he worked out how to get KTrip into F-Droid, the free software app store for Android.

Then, the developer tool ELF Dissector passed kdereview, meaning KDE has approved it as something we are happy to put our name on when it gets released. It's a static analysis tool for ELF libraries and executables. It does things like inspect forward and backward dependencies (on a library or symbol level), identify load-time performance bottlenecks such as expensive static constructors or excessive relocations, or size profiling of ELF files.

Help Out

By getting KDE's apps into the most popular of channels like the Windows Store, Google Play and F-Droid, we can reach more users and boost KDE's adoption through its software. Now that Kate is successfully shipping in the Windows Store, Kate developer Christoph Cullmann wrote a guide to Windows Store submission. Check it out.

KDE's All About the Apps Goal has loads of other things you can do to help get our applications to users, so come along and give us a hand.


Backstory

Few days ago I wanted to play with Falkon and create some basic Qml plugin. (What else to do to play, Python support is broken and C++ is for built-in plugins).

I started KDevelop (the big IDE I use) and went to create new Empty project because as I am not big Qml lover I did not create template for it yet. But I was met with errors which made me change my focus and fix the tool I use (KDevelop) before playing with Qml and Falkon.

Man must shape his tools lest they shape him. - Arthur Miller

Problem

During the project creation AppWizard is trying add files and than commit changes into new DVCS (Decentralized Version Control System) repository. When there are no files to add there will naturally be nothing to commit which results in error message from DVCS and the project creation is stopped and project removed.

Solution

Lets dive into KDevelop code and check what can be done about it. My humble solution relays on checking the state of the DVCS repository before commit. To achieve this I am trying to get actual status of the repository from VCS (Version Control System) and then checking if the result contains some items.

The KDevPlatform provides nice API to work with VCSs and thus I only need to call few method to get all the data.

Actual code is truly simple and works for me. (only my changes)

qCDebug(PLUGIN_APPWIZARD) << "Checking for valid files in the DVCS repository:" << dest;
job = dvcs->status({dest}, KDevelop::IBasicVersionControl::Recursive);
if (!job || !job->exec() || job->status() != VcsJob::JobSucceeded)
{
    vcsError(i18n("Could not check status of the DVCS repository"), scratchArea, dest);
    return false;
}

if (job->fetchResults().toList().isEmpty())
{
    qCDebug(PLUGIN_APPWIZARD) << "No files to add, skipping commit in the DVCS repository:" << dest;
    return true;
}

Brief description

  • Print notice into debug output
  • Prepare job with status command to run
  • Execute the job and check for failure
    • If failed put notice in debug output
  • Check if the response contains some items
    • If not put notice in debug output
    • Skip add files & commit by returning true
  • Test many times and done.

Results

KDevelop is able to create Empty project from template with initialized DVCS repository which is really helpful when one wish to start a project from scratch.

Git

Works just fine.

Bazaar

The world is never perfect and there is always a room for improvements.

The merge request is waiting for review at invent.kde.org !73.


The Plasma Mobile team is happy to present the sixth weekly blogpost. This week’s update is full of application updates, which is in line with KDE’s goal of KDE is all about apps.

Libraries

Kirigami

Kirigami’s Card component now uses gradient stops instead of blur, which improves performance on low performance GPUs. The ColumnView component has improved flicking behavior, its flicking gestures should now feel more natural and easier to use.

Mauikit

The improved SelectionBar component behaves more like most touch applications in selection mode. Now the SelectionBar has a list of actions to perform on the selected files. The SelectionBar can still group files or items across different locations. A list is shown to peek at which files have been selected and allow adjusting the selection.

Index selection bar

The templated delegates used by Maui apps in list and grid views have been polished even more. Additionally, they are now used in more places.

Applications

Phonebook

The instant messaging actions in the phonebook now show the display name of the service instead of the protocol. Its editing mode now fits smaller screens and is displayed correctly. For this a fix has been landed in Kirigami.

qrca

The QR Code scanner now supports optauth:// uris, which will in the future be handled by the Keysmith application. It now also tries to set the camera to a specific format to prevent it being unable to decode an unexpected format.

Okular

Okular’s search bars now work correctly on Plasma Mobile.

vvave

In vvave tracks can now be quickly appended or removed from the main playlist using dedicated button. It also can save the current playlist to a personal playlist now.

vvave quick actions

The new focus view has been improved visually.

vvave focus view

vvave can quickly filter tracks if the list is big enough using the templated data models from MauiKit.

vvave filtering

Upstream

Ofono phonesim, an application that can be used to develop SMS and telephony applications, now supports Qt 5 upstream.

Currently plasma-phone-components and plasma-nano repositories are part of playground, recently they were moved to kdereview, once the review process completes successfully, they will be moved to kde/workspace and will be released along with Plasma 5.18.

Events

Some of us attended the Qt World Summit 2019 in Berlin. At our booth we demo’d Plasma Mobile running on Nexus 5X and Purism Librem 5 devkit.

PlaMo at QtWS 2019

Want to be part of it?

Next time your name could be here! To find out the right task for you, from promotion to core system development, check out Find your way in Plasma Mobile. We are also always happy to welcome new contributors on our public channels. See you there!


November 07, 2019

void DeviceListing::populateListing(const show showStatus)
{
const Solid::DeviceInterface::Type needHardware[] = {
Solid::DeviceInterface::Processor,
Solid::DeviceInterface::StorageDrive,
Solid::DeviceInterface::Battery,
Solid::DeviceInterface::PortableMediaPlayer,
Solid::DeviceInterface::Camera
};

clear();

for (unsigned int i = 0; i < (sizeof(needHardware)/sizeof(Solid::DeviceInterface::Type)); i++) {
QTreeWidgetItem *tmpDevice = createListItems(needHardware[i]);
deviceMap[needHardware[i]] = static_cast(tmpDevice);

if ((tmpDevice->childCount() > 0) || (showStatus == ALL)) {
addTopLevelItem(tmpDevice);
}
}
}

in C++11 you can rewrite it in the much easier to read

void DeviceListing::populateListing(const show showStatus)
{
const Solid::DeviceInterface::Type needHardware[] = {
Solid::DeviceInterface::Processor,
Solid::DeviceInterface::StorageDrive,
Solid::DeviceInterface::Battery,
Solid::DeviceInterface::PortableMediaPlayer,
Solid::DeviceInterface::Camera
};

clear();

for (const Solid::DeviceInterface::Type nh : needHardware) {
QTreeWidgetItem *tmpDevice = createListItems(nh);
deviceMap[nh] = static_cast(tmpDevice);

if ((tmpDevice->childCount() > 0) || (showStatus == ALL)) {
addTopLevelItem(tmpDevice);
}
}
}

November 06, 2019

We are happy to announce the release of the Qt Visual Studio Tools version 2.4.2!


At the 2019 Libre Graphics Meeting, illustrator Livio Fania presented a heart-felt plea for more professionalism in libre graphics.

And that was the moment I began to think a bit. What is it that makes one project professional, and another not? Where, in this case, I’d take “professional” to mean “someone can depend on it so they can earn their daily bread with no more than the problems you always have with any software, because all software sucks, and hardware even more so”.

As Livio said in his presentation, funding makes a difference. If a project can fund its development, its continuity will be better, it will be better able to implement its vision and deliver what it promises, simply because funding equals time. That’s also what I tried to argue in my previous blog post.

In practice, it’s very hard to find funding for applications that that people do not earn their income with. Of course, there are very accomplished free and open source video players, editors or file managers. Those tend to be still completely volunteer-driven and very underfunded. And there’s a reasonably successful web-browser, which is actually funded quite well — but it’s funded to avoid Google being broken up as the monopolist that it is, mainly by Google.

And of course, there are applications that people use daily, earn their bread with and that are completely unfunded, even if they have donation buttons and money in the bank: GIMP, Inkscape, Scribus, various RAW photo applications, often by choice. This means that those projects are even more squeezed for time than a project like Krita. Just think how much difference Tavmjong Bah would make if he could be funded to work on Inkscape full-time! Tav gets $107 a month through Patreon… (Which I contribute too.)

But though Livio focused on the need to get funding to accelerate development, and it’s the first step, there’s more to creating a professional application.

The second step is: focus on the user’s needs. That starts with knowing what you want to create. If your goal is to implement a standard specification fully, as is the case with Inkscape, then is that goal sufficiently user-oriented to form the basis for an application designers can earn their daily bread with? It’s possible, but it’s something to always be aware of.

And like I argued recently, is looking inward, discussing the where’s and why’s of Free Software, no matter how enjoyable, not taking away time better spent getting to know your userbase, their needs and… The competition.

I would not be surprised if visiting the Linux Application Summit next would be less useful for Krita and its users than a week long training in Photoshop would be for me, as the Krita maintainer. We’ve all been there: we’ve all claimed we’re not competing with the big, sovereign, proprietary applications that are seen as a standard in the field where our application is the “open source alternative”.

But if you don’t compete, you cannot win. And if you don’t win, then millions of users will not use free and open source software. And I happen to believe that software freedom is important. And I’m slowly gaining the confidence to say: I am competing.

(And we are. Competing. Otherwise Adobe wouldn’t have been adding so many new features for painters and illustrators to their latest Photoshop release, some of them features Krita has had for a decade.)

And when we compete, which makes people trust us, and when our user fund our efforts, then we need to take another step towards professionalism.

That is, committing to continuity. I’ve always said “free software never dies”, but it does. Look at Amarok, which is thoroughly dead. Of course, Krita has been released since 2004, and there’s quite a bit of continuity already. But this does take commitment, which also needs to be public.

Finally, there’s the point where as a full-time project member, as the project maintainer, can no longer say “We don’t provide binaries. Get the source and build it, or wait for a distribution”. You have to provide your application in a form your users can use directly; it’s their time you’re telling them to use for something they don’t earn money with, if you ask them to build.

And then… We have to stop making excuses. Which is probably the hardest thing, because all software sucks, and all code sucks, and sometimes it’s impossible to fix a bug in Krita, because it’s in the OS, the Window manager or the development platform. Or the tablet driver, oh dear, the tablet drivers. But it’s your customer, your supporter, the person who depends on your work to earn their money who is stopped from doing that. And suddenly workarounds and hacks become necessary.

So, funding a core team of developers is the start, focusing on the field instead of the free software community, a will to compete, providing continuous improvement, making sure your software can be used and finally, not making up excuses if there are problems but fixing them.


I've been using the Google login for authentication for my application. The chain of events is as follows:

  1. In the browser a Google login where you either enter your account information or select from an already logged in Google account.
  2. The Google login libraries talk back and forth, and come up with a token.
  3. The app sends the token to the node application, where it verifies it's validity, extracts the identification of the user, verifies against the allowed users, then responds with the authentication state to the app in the browser.
  4. The angular app watches all this happen in a guard, and when you are authenticated routes to wherever you wanted to go.
It all works fine, but I was running into two issues. 
How do you authenticate a websocket connection? I wrote the logic where the token was sent via socket, and the connection is maintained if the token is valid. But I don't trust my code when it comes to security.
The second issue is that the normal garbage traffic that hits any server gets a large app bundle, putting an unnecessary load on the server. Even if you lazy load and start with a simple log in page, the bundle is not insignificant.

I was forseeing complications as I built out my app. I wanted security to be simple, audited by people who know, covering websockets and api calls, and not being a burden on the server.

I ran across an application called oauth2_proxy, which seems to solve my problem. You put your application and all the api routes behind this proxy, which authenticates via the numerous oauth2 services available, including Google.

I set it up and got it working, then realized that I needed something very similar to my server deployment on my development machine. Knowing from experience, the setup of these things are complex and long, and I wanted to figure it out once, then change a few things and have it ready for deployment. Docker came to mind, partly because the oauth2_proxy has a docker image.

So my structure is as follows. I have it basically working, no doubt I'll find a bunch of issues, but that is why I wanted it on a development machine. I'm using docker-compose to put the thing together, and the goal is to have it ready to go with one command.

  1. Nginx as a front facing proxy. The docker image takes a configuration file, and it routes to the nodejs api applications, websockets and all the bits and pieces.
  2. Oauth2_proxy for authentication. I'm using the nginx auth_request function where a request comes into nginx, and on the locations needing authentication it calls oauth2_proxy then routes either to a login page or the desired route.
  3. Nestjs server application that handles the api calls
  4. A second nodejs application that does a bunch of work.
  5. A third nodejs application that serves websockets.
  6. Mongodb as the data store. The websocket microservice subscribes to changes and sends updates to the app in the browser.
  7. For development, I have a docker image which serves the angular-cli ng serve through nginx. The nodejs applications are also served the same way, meaning they recompile when the code is changed.
So how does it look? I'll go through this piece by piece. There were some knarly bits which swallowed too much time with a dastardly simple solution obvious only in retrospect.

Setting up a MonoRepo with Nx

When I started poking around with this idea I found that the structure of my application was lacking. Things like shared code between Angular and Nestjs, and the serve and build setup for the node applications didn't work very well. A very nice solution is the Nx system. It required a bit of work and thought to move things around, but in the end I have a setup where ng serve api starts the node application in development mode. https://nx.dev/angular/getting-started/getting-started shows how to install the system. When you install it will ask the structure of your application, I selected angular with nestjs backend. It creates a skeleton that is very nice.

Running Angular Cli in Docker

This is really neat. Here is the Dockerfile.

FROM node

ENV HOME=/usr/src/app
RUN mkdir -p $HOME
WORKDIR $HOME

RUN npm -g install @angular/cli@9.0.0-rc.0

EXPOSE 4200

USER 1000

Put this Dockerfile in the same directory as the package.json file in the Nx structure. I call it Dockerfile.angular, since I have many dockerfiles there.

Then in a docker-compose.yml file, the docker-compose configuration,

angular:
  container_name: angular
  build:
    context: .
    dockerfile: Dockerfile.angular
  ports:
    - "4200"  volumes:
    - .:/usr/src/app
  command: ng serve --aot --host 0.0.0.0

The volumes: statement lets the docker image see the current directory, then you run ng serve and it serves the application. I'm using it from an Nginx proxy, so the port is only seen from the docker network. You might want to expose it 4200:4200 to use it without Nginx.

The node applications are identical except for the Dockerfile EXPOSE statement where I set the value to the port that the Nestjs is watching. And instead of ng serve, this is what the docker-compose.yml looks like.

scripts:
  container_name: scripts
  build:
    context: .
    dockerfile: Dockerfile.scripts.dev
  ports:
    - "3333"  volumes:
    - .:/usr/src/app
  command: ng serve scripts
  depends_on:
    - mongo-replicator
  secrets:
    - mongodb_username
    - mongodb_userpwd
    - mongodb_path
ng serve scripts runs the node application. There are a couple things here that I will get into in future posts.

ng serve --aot --host 0.0.0.0 This is one of the sticky things I had to figure out. The default host is localhost, and the websockets for live reloading the app in the browser won't work unless you set this correctly.

More to come.

  1. Docker secrets and using them in the various images
  2. Setting up Mongo.
  3. The Oauth2_proxy configuration
  4. Nginx configuration



November 05, 2019

Apple having decided it wants to deep inspect any application you might want to run on your Apple computer, has made what it calls “notarization” mandatory with macOS Catalina. Inevitably, Apple’s documentation on the subject is highly defective, like most developer documentation Apple provides.

We figured it out, in the end. It adds about half an hour to an hour, depending on how busy Apple’s computers are, to the build and release process.

What happens is this: we build Krita, then we create an app bundle. Then we zip up the krita.app bundle and transfer the zip file to Apple, which then checks whether Krita uses any forbidden API’s or contains its own html rendering engine and other such things that are highly dangerous for the well-being of the computers it allows its customers to use. Then we get a long string of numbers and letters back, which we can use to periodically check whether Apple is done checking. This can take ages, or happen relatively quickly. Then we need to execute a command to “staple” Apple’s imprimatur to the app bundle.

Then we package the app bundle in a disk image, and… Upload that to Apple, which does the checking once again. We wondered whether it would be enough to “notarize” only the disk image, or only the app bundle, but after booting into Catalina, it appears that both need to be “notarized”. We might still be mistaken, of course, and there might be ways to only upload Krita once to Apple. In any case, once more we wait for Apple to finish rooting around in the disk image, and if we get Apple’s blessing, we once more go through the stapling thing, and we can upload the disk image for you to download.

We did that for our last stable build:

Note: you will have to make sure that the “Native File Dialogs” option is disabled, otherwise you cannot save files!

Weird but true, the checking for saving permissions seems built into the file dialog, not in the file system, so we still have to figure that out. Also be aware that notarized applications take a long time to start for the first time.

Another option could be to drop Apple and macOS as supported platforms for Krita, which wouldn’t be too bad a thing, what with broken OpenGL drivers, the push for proprietary API’s, interference with what application developers are allowed to do and broken-by-design hardware.


We are happy to announce the release of Qt Creator 4.10.2 !


After the recent release was finalized, there is some time now to have a (very) short break in the development, to take care of some organizational topics around the project and to set the development priorities for the next release. But there is also some time now to look back at where we started several years ago and where we are now. In this blog post we want to look at the history of the code base.

LabPlot is quite an old project started long time ago, back in KDE3 times. One of the important milestones of this project was the complete rewrite using Qt4/KDELibs4 in 2008. This is when new developers joined the project, at least for a certain period in time, and when the jump from 1.x to 2.x release versioning was done for LabPlot. Starting from zero and lacking a lot of features in the 2.0 release, we gradually evolved release by release by implementing new features and by improving the code base.

SLOCCount is a handy tool to determine the number of source lines of code (SLOC) for every language used in the project. Besides counting the lines of code, this tool provides some other metrics to estimate the development costs. For this, SLOCCount can use internally different models to estimate the project costs. On default, the Constructive Cost Model (COCOMO) is used.

Running SLOCCount on LabPlot’s code for all 2.x releases leads to the following numbers:


SLOCCount History

We have ca. 100k lines of code in total with the major parts written in C++ (ca. 95%) and in C (ca. 4%) and with much smaller contributions of shell and python scripts used in some tests and of the syntax definitions for GNU Bison. The latter is used internally for the parser of mathematical expressions.

The role of C++ in a Qt/KF based application is clear. C is used for mathematical algorithms in our project. This C-code, internally called Numeric Scientific Library (NSL), goes beyond what is offered by GNU Scientific Library (GSL), that is used by LabPlot already for many different things like FFT, interpolation, etc. In future, if time and resources permit we can think of bringing NSL into GSL or releasing it as library independently of LabPlot.

For LabPlot, having only two core developers over the last years plus some irregular contributions from other developers and GSoC-students, this model heavily over-estimates the number of developers involved in this project. Similarly, the development effort is over-estimated which probably has the same reasons.

So, we show all these numbers without going too much into the details of COCOMO and without elaborating on trust we put into the numbers calculated based on the heuristics and assumptions behind this model. And we don’t conclude from these numbers that we over-perform the “average developer” used by COCOMO and SLOCCount to estimate the effort and costs 🙂

It is also interesting to see how the code base grew release by release and how long it took for us to do the actual release. This information can be easily collected with git and by checking the release dates:


Git History

To get meaningful results for “Days between releases” in this visualization we don’t show the first 2.x-release, being 2.0, and start with 2.1.

The number of insertions and deletions shown here counts also changes done on the documentation files, tests files, etc. and doesn’t sum up to the total number of SLOCs shown above where only the actual source code is considered.

The relatively small number of new code added in 2.7 is because of the overall focus on stabilization and polishing done in this release as also stated in the release announcement for 2.7.

We’d like to release more frequently. This is not always easy given the limited amount of resources on our side. But the overall trend for the last two releases goes into the proper direction and we want we can keep this trend and momentum for the next releases.


We’re in autumn for a little while now and not quite winter yet… It’s time for another post about KDE PIM! I’ll be your host to cover September and October and will try to follow in the footsteps of my peers who did a great job the past few months. Unlike Franck, I won’t start with the stats though, you’ll get that at the end. Is it obvious that I’m trying to make sure the stats addicts read through. ;-)

Akademy

As you might have noticed, lots of us gathered to Milano for Akademy. Lots happened there regarding KDE PIM. It was partly covered in Volker’s post about Akademy 2019 already, but it’s good to highlight a few things.

One of the most important events there is the increasing collaboration with the Plasma Mobile team, which shows in the Plasma Mobile Akademy 2019 recap. This is to be expected in some way, after all, lots of your Personal Information Management happens on mobile these days, it’s a natural match between those two teams.

This leads among other things to Dan’s work on KAccounts integration in KDE PIM. You can see how the prototype works in the video below, it shows a Google Account integrated with KOrganizer and KAddressBook and controlled from the Online Accounts settings:

KDE Itinerary

Per usual this one is covered separately in its own series by Volker:

GUI Fixes

From Volker again, we got lots of small fixes all over the place about icon and icon size. It was motivated by preparing for KF6 work but it turns out quite nice for high dpi users as well.

KMail

Volker made the actions of the itinerary plugin for KMail easier to discover. It looks quite nice now:

KMail Itinerary Plugin

In the meantime, Laurent has been working on three new features for the next release!

First, if you ever hit send too quickly and then regretted it because you forgot to finish a sentence or such, you’re going to love this. We have the “Undo Send” feature which got introduced. This allows to define a delay before an email gets really sent. During that delay you then get a notification which allows you to cancel sending.

Undo Send Notification

Second, Laurent introduced the “Quick Text” plugin which improves snippet support. This enables the user to have variables for most fields which are usable in snippets. Later on when the snippet is inserted in the composer, all these variables will automatically match the corresponding fields (date, name, from, etc.).

Quick Text

Third, a nice feature regarding security and privacy. DKIM support is implemented straight in KMail. This allows your beloved mail client to verify that an email was really sent by the mail server it’s supposed to.

DKIM valid DKIM invalid

And of course, there’s been Laurent’s usual activity on fixing bugs, removing the use of deprecated functions and preparing to port to KF6.

Frameworks

This is the big news, some parts of KDE PIM are now in KDE Frameworks!

In particular, KCalendarCore and KContacts finally landed there and are introduced publicly in KDE Frameworks 5.63. This will definitely help users which are not part of KDE Application release which were forced to have dependencies on PIM (Plasma Mobile and Zanshin come to mind but there are more).

The next target to end up in KDE Frameworks is KDAV. The work started on it, mainly focusing on ABI stability, reducing the public link interface and adding fixes in KIO (where they belong) instead of working around them within KDAV. Also very importantly: the agreement to relicense to LGPL has been reached, so the remaining non LGPL parts can be adjusted.

Indirectly related, Dan has been cleaning up the API of KAsync which is not used a lot yet but will get more important in the future. Indeed there are plans to introduce an easier to use Akonadi client API which would depend on KAsync. Stay tuned!

Community Analytics?

So, I’ve been in a long hiatus regarding my community data analytics posts (or any posts for that matter). Some of you might wonder… is it gone? Will he ever do any colored blobs again? Fear not my friends, the opportunity was too nice, here comes your fix of data visualization.

A big shout out to all those who participated in KDE PIM work the past couple of months. Thanks a lot! It’s a very important job you’re all doing, they know who they are, but here is the activity graph of the past two months, so now everyone know who they are (offer them drinks if you get the chance!):


In the past two months, we had 25 different developers on KDE PIM. And of course, since my data is coming only from git, this unfortunately misses people who helped with bug reports, docs, design etc. Whatever your contribution you can be all proud!

I’m using the opportunity to point out an unsung hero of KDE PIM: David Jarvie! This man has been around longer than I remember, and you can see he’s still fairly active.

Now, how does the code contributor network looks like?


Unsurprisingly the two most influential ones are Volker and Laurent. You can also see three extra persons fairly central to the network: Yuri Chornoivan, David Jarvie, David Faure and Friedrich W.H. Kossebau. All those people have their hands in many pies and that’s very much needed.

You might also notice disconnected nodes in the graph. I often make the mistake to not talk much about those in my posts… But it doesn’t mean they’re not important! For an healthy open team you need some of those less connected nodes: they tend to come and go while focusing for a short time on less noticeable issues. It is very important for our users to get a nice experience in the end.

In the end, what I like about this graph in KDE PIM is that we get something relatively well balanced in term of very connected nodes and much less connected nodes.

How You Can Help

Next time, your name could be in visualizations like the ones above!

Check out the KDE PIM Development wiki and find out how to be part of something that matters. If you want your share of this or need help to get started, feel free to contact us #kontact and #akonadi IRC channels on Freenode.

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


November 04, 2019

KDevelop 5.4.4 released

We today provide a bugfix and localization update release with version 5.4.4. This release introduces no new features and as such is a safe and recommended update for everyone currently using a previous version of KDevelop 5.4.

You can find the updated Linux AppImage as well as the source code archives on our download page.

ChangeLog

kdevelop

  • Fix copyright date display in About KDevelop/KDevPlatform dialogs. (commit. fixes bug #413390)
  • FindClang.cmake: also search LLVM version 9. (commit)
  • Clang: Workaround for empty problem ranges at start of document. (commit)

kdev-python

No user-relevant changes.

kdev-php

No user-relevant changes.

kossebau Mon, 2019/11/04 - 19:02
Category
Tags

We are happy to announce the release of Qt Creator 4.11 Beta2 !


Freshly returned from the 2019 Blender Conference, Krita project maintainer Boudewijn Rempt was heard to wistfully wish for something like Blender Artists, only for Krita. A central place for artists who use Krita to discuss their work, ask for help, share experiences and reach out to developers. And in the interest of growing the community, not something that needs to be maintained and developed by the current development team, the Krita Foundation or the KDE community.

Raghavendra Kamath, a professional illustrator who has used Krita for years and years accepted the challenge and has setup over the past week a new website: krita-artists.org. It’s brand new and still slightly experimental, but we’re announcing it today!

Go out and have fun!


November 03, 2019

Recently I wanted to try how virgil, the OpenGL solution for KVM/Qemu, works with KWin. Virgil (sometimes also referred to as virgl) is a wonderful solution, but so far I hadn’t been able to test it. Especially I was interested in seeing how it works with Wayland. Unfortunately I did not find much information on how to setup a VM which supports virgil, so a good reason to write a blog post.

As base setup I used Debian testing, as guest system KDE Neon Developer edition, for virtual machine management Virt-Manager. To enable virgil support one needs to configure the Video device with Model “Virtio” instead of QXL which was common in past. When using the Virtio driver there is a checkbox “3D acceleration” which needs to be checked.

But this is not the only place where adjustment is required. In the “Display Spice” section one needs to check the “OpenGL” checkbox. It allows to select the graphics device. For me “Auto” just worked fine, but I only have one GPU installed. On “Listen type” one needs to select the “None” entry. Otherwise you get a very cryptic error when trying to start the virtual machine.

With these adjustments the virtual machine was ready to go and I got the sddm screen (which uses OpenGL). So all good? Unfortunately not: sddm seemed frozen. Disabled virgl, booted again, reconfigured sddm to do auto-login, enabled virgl and restart. The desktop loaded, KWin was picking up OpenGL, Plasma was properly blurred. Also a restart into Wayland worked without any problems. But KWin of course does not really know about virgl yet and just shows an unknown device when checking the support information.

As I had installed a developer edition, I wanted to give this a try. Started kdevelop, checked out KWin, edited the relevant sources, compiled, installed, committed. I was very pleased with the out-of-box experience for hacking on KDE software on KDE neon developer edition. In less than 2 hours I went from setting up a VM to pushing the accepted change to the git repository. And the largest challenge was setting up phabricator (arc is not installed, though migration to gitlab…) and getting my ssh key into the VM. The result is KWin detecting the virgil renderer in support information (screenshot taken on X11):

I hope to find some time to investigate why sddm seemed frozen – this is unfortunately currently quite a little bit of a showstopper for using virgil. Otherwise I am very pleased with the results. Having a working virtualized GPU is a big step for Linux as it allows to run modern desktop environments such as KDE Plasma and GNOME on a full free software virtualization stack.


Hello y’all.

This is a very simple post: a disclaimer, some forgotten information I need to include, sources and more.

Disclaimer

I am biased. This should be taken into account when reading my blog. I’m not a journalist who proclaims I am here to provide you the truth, I’m just one person writing some stuff.

As a human, I’m fallible; as a non-programmer and non-designer, I’m only capable of discussing such things, I cannot be a reference material for specific subjects.

Subjects I can discuss safely are translation/localization, language learning, linguistics (relatively so), social psychology (fandom and fan studies), ergonomics, a little bit of physical therapy, anxiety countermeasures and dentistry.

Subjects I cannot discuss safely are how a program works internally, design rules/patterns, proper development, journalism, editing/desktop publishing, color theory, OSX (since I haven’t used it, and won’t ever use it, since in my country Apple stuff costs three times their original overprice—and somehow people still buy it).

I also should be explicit with certain privacy concerns my readers might have. I very much appreciate the concept of transparency in handling financial, management and privacy matters.

This WordPress page right here is self-hosted and so I have complete control over it. As such, I do not and will not include ads here, unless I get into financial trouble. If I ever find myself in such a situation, I’ll ask for donations (I pay like R$40 for this VPS every month, which in dollars would be something like $10, which is enough).

I also have a few plugins, one of which is that GDPR Cookie Consent plugin over the top. When I saw that this plugin has the option for blocking content before cookies are accepted, I immediately felt cautious because this is a terrible practice similar to paywalls, and a dutch furry lawyer who is a friend of mine sent me this interesting article concerning Dutch data protection, which includes de brontekst in het Nederlands. Awareness is nice. I will never do such a thing as cookie walls (I’m a fan of open access, after all).

Now that I checked, I don’t even seem to use cookies, but I’m keeping the Cookie Consent plugin just in case.

I have Statify set up so that I can somehow track users visiting my blog without assumedly violating their privacy, as they say: “Statify counts site views, not visitors”. It’s open source and very minimal, which is nice.

If you know of nice privacy/security-related plugins or some security hardening I can do to improve my blog, do mention it, please. 🙂

In addition, for those expecting my analyses, I have two things to say:

  1. I will focus mostly on system keyboard shortcuts, not application shortcuts; that will be for later on.
  2. I have to take my time with that because I have like 7 personal projects, socializing and resting is important, and because I need time to test each Desktop Environment.

Next week I’ll post the next post of the series, though.

Addendum

I forgot to include some information in my GNOME post, though those are small details.

For testing GNOME, I installed vanilla-gnome-desktop on my work machine which includes Kubuntu 19.04 (with backports), and later on I removed vanilla and installed ubuntu-desktop with –no-install-suggests and –no-install-recommends and later on without. I didn’t see that much difference GUI-wise aside from a few tweaks made by Canonical.

I also used a Fedora 31 liveUSB on both my work and home machines. It works significantly more snappy than Ubuntu 19.04 GNOME and several levels of magnitude better than that of 18.04, so kudos to the GNOME team!

I used literally all sources available for checking out on GNOME shortcuts:

  • https://www.cheatography.com/frieser/cheat-sheets/gnome/
  • https://wiki.gnome.org/Design/OS/KeyboardShortcuts
  • https://help.gnome.org/users/gnome-help/stable/keyboard-shortcuts-set.html.en
  • https://developer.gnome.org/hig/stable/keyboard-input.html.en
  • https://help.gnome.org/users/gnome-help/stable/shell-keyboard-shortcuts.html
  • https://help.gnome.org/users/gnome-help/stable/keyboard-nav.html.en

It would have helped if there was a huge, comprehensive, table-like dataset concerning keyboard shortcuts listing all keyboard shortcuts at the same time and providing additional information such as when it was planned and effectively introduced (like Design/OS/KeyboardShortcuts) in addition to justification, considering the amount of thought that was put into that.

I’ll update the GNOME post today so as to include this information concerning the materials required.

Celebration

The userbase page for KDE Connect is mostly finished, yay! The userbase page serves to explain the usage of the software whereas the community page is geared towards contributors and intermediate to advanced users, as well as non-traditional use-cases.

My home laptop finally is not a potato, yay! It now has a 240GB SSD and 16GB of RAM, which means I’ll be spinning several Virtual Machines and properly experiment with different systems, such as Gentoo, LFS, Void, etc.

I’ve finally surpassed the 90% translated for the Brazilian Portuguese translation of Scribus, yay! It was a huge ton of work considering that when I started it was at around 58% (I think). The whole project includes 29,310 words and 7,730 sentences/segments. The huge majority of those segments are tooltips and hints. The main developers are very thoughtful in this regard: even if you know nothing about desktop publishing, you can learn a whole lot about it simply by reading those tooltips. Translating them made me interested in the area, too. I won’t be able to reach 100% in the near future though because I require help from an expert in desktop publishing lingo for some stuff, such as spot colors.

I am now a “KDE developer”, yay! I’ll be translating much more now that I can push those translations, and hopefully I’ll be able to maintain the KDE announcements in Brazilian Portuguese. Localization for something as big as KDE is a huge task, any help would be appreciated. It’s also fairly easy to work with us, if you’d like.

I managed to help Carl Schwan with the websites, yay! You see, there has been a lot of work concerning kde.org, and while most of that is related to updating outdated information, part of that is also porting websites. Carl has been doing a lot of work and explained to me how to do some of that porting, and despite me knowing very little of html/css/php/markdown, I actually managed to do a few pages, it was very nice and not difficult at all (though I’m pretty sure a lot of stuff is, I just managed the easy stuff I think). There is so much to do that it felt very overwhelming, and I am sure that he’d appreciate your help! His nick on Reddit is ognarb1, and he can be reached through the IRC, Matrix and Telegram KDE groups.

This provided me with an idea for the next series: differing tutorials on how to contribute to KDE.


To increase the visibility of KDE applications on Windows, the KDE e.V. has a Windows Store account to publish our applications there.

This is not the only way to get KDE application for the Windows operating system, you can e.g. directly grab installers or portable ZIP files from our Binary Factory.

There is at the moment no nice documentation how to submit some application to the store.

Hannah did show me how to do that during the submission of Kate and I did it later for Okular and Filelight.

Therefore I will now show the submission process for a new application in detail.

Each step has some screenshot of the web interface you need to use.

This requires that you have access to the KDE e.V. partner center on the Microsoft site shown below.

You can request access from our KDE system administrators. To have this coordinated, please show up on this Phabricator task.

Creating a new application

You start your submission of new applications on the “Windows -> Overview” page of the partner center.

Just click there the “Create a new app” button.

Choosing the application name

Next step is to select the application name.

For this guide, we will use Kile (and no, Kile is not yet submitted to the store, that will be finalized later, see this task).

Starting a submission

Now we have a fresh generated application on the dashboard.

The next steps is now to create a first submission, for this you need to press the “Start your submission” button on the overview of the new application.

A submission is a bundle of both a new application version and the needed meta-data for the store, e.g. screenshots & descriptions.

Fill out the different submission parts

You will end up on the overview page of the new submission.

The important parts to fill out are the top five

  • Pricing and availability
  • Properties
  • Age ratings
  • Packages
  • Store listings

Submission: Pricing and availability

For the pricing stuff, the defaults are sufficient for the most parts.

We want to have our stuff visible for public audience and we want to have it discoverable.

The default release schedule is fine, too, release as soon as possible and no end time for availability.

The only thing that needs here adjustments is the pricing, this should be set to “Free”.

Afterwards, you can press the “Save draft” button at the bottom of the page.

Submission: Properties

For the properties stuff, most important is the top part.

Very important: The category/subcategory for the store! People will not be able to locate your stuff easily if you choose there some contra-intuitive stuff.

For example, Kile should be in something like “Productivity”, like other tools of that kind. If unsure, just browse a bit through the Microsoft store and take a look which kind of applications are where.

KDE provides a privacy policy website you can link to.

Below, insert the homepage of your application and the best location to get contact to you.

Most applications should have some contact/support/… page for this.

At the bottom you can configure some other things like system requirements.

For example Kile for sure wants some Keyboard or Mouse like input.

After you are done, scroll down and press the “Save” button.

Submission: Age ratings

For age ratings, just follow the wizard.

This is more or less what you would expect. As the typical KDE application shall not contain sex, violence or other stuff of that kind, this should be straight forward. Below my input for Kile.

Press “Save and generate” and be done.

The results will show up and if you see no issues, press “Continue” to finalize it. As visible, Kile is applicable more or less to all ages.

Submission: Packages

Now we get to submit the real “installer”.

This is the “appxupload” package the Binary Factory will create for you.

For example for Kile, you can grab the latest release build at Kile_Release_win64.

Before you upload stuff there, please really test this manually first!

Broken versions make a very bad impression.

I will only upload here some test version for the guide, later this will be replaced with a proper version before we submit Kile!

You can locally test on Windows the sideload.appx variant without going through the store, just click on it to install it locally.

For operating systems, at least select “Windows 10 Desktop”.

After the package got successfully uploaded and validated, press “Save” to be done here.

Submission: Store listings

Store listings are per language.

We start with the default, “English (United States)”.

If you like, you can later add more languages there.

But keep in mind: You will need to update them manually on each new version, if you don’t want to have the different languages with completely different store descriptions or screenshots.

To start with the English variant, click on the “English (United States)” link on the submission overview as seen below.

You will now end up on a page that allows to insert the usual stuff for an application store page.

Important here are for example:

  • Description
  • What’s new in this version (important for later update submission)
  • Product features (this is a list, add one feature in one field, you can add new fields with “Add more”)
  • Screenshots (the interface is a bit buggy, always take a look if e.g. the captions for the screenshots you added is still all right at the end of your editing)

A good location to grab this stuff from is the appdata.xml for your application.

For example for Kile you can grab this from the KDE applications page for Kile.

After your are done, as always, press “Save” at the bottom of the page.

Done => Press the button!

Now after you are done with this, you can just press the “Submit to the Store” button on the submission overview!

The application icon will show up properly in the web interface after the first submission is done, too.

For Kile, we still need to do final polishing before we can do this.

Updates?

If you have your initial submitted application version in the store, updates are just new submissions.

Just head to the overview page of your application on the partner page and hit the “Update” button in the “Submissions” section.

The data from the last submission will be retained, you just need to upload a new installer + update the store listings page with “What’s new in this version” and new screenshots if required.

Join the Discussion

Feel free to join the discussion at the KDE reddit.


This week we continued fixing bugs in Plasma 5.17! We know that it was a bit buggier than the 5.16 release was, and we strive to do better. If you’d like to help out with this, please test our Plasma beta releases by switching to the unstable/beta testing repos in your rolling release distro of choice. For example, Arch and openSUSE Tumbleweed. Beta releases of KDE apps will show up in these repos as well. It’s super fun! Try it, you’ll like it! 🙂

New Features

Bugfixes & Performance Improvements

User Interface Improvements

How You Can Help

I mentioned testing Beta releases earlier, but here’s something else! Do you like the idea of running a KDE-endowed free software operating system on your phone? I know I do. But did you know that KDE already has a mobile platform called Plasma Mobile? It’s real and it works and it needs your help to become mainstream! If this sounds like your cup of tea, check out https://www.plasma-mobile.org/findyourway/. You can read the Plasma Mobile project’s weekly updates in a format similar to this one here: https://www.plasma-mobile.org/blog/

More generally, have a look at https://community.kde.org/Get_Involved and find out more ways to help 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.


November 02, 2019

Day 1

I had to wake up really early and since I went to sleep very late the previous evening… and couldn’t sleep… I got like 1.5h of sleep. Fortunately, I didn’t have any unfortunate events because of that, everything went fine. I ate my nutella sandwich and took two ham sandwiches to eat later. Got through the luggage control, then other luggage control – weighing and checking boarding passes. The flight was delightful and beautiful – I’ve taken so many photos!

The flight started in a very clear, sunny air over Warsaw, but ended in a cloudy Amsterdam. The layer of clouds was so thick that before the plane started landing, buildings were still super small beneath us; and then the plane started to lower its altitude and flied into the clouds, and when the clouds started clearing up, the ground was so close – I’m sure there was less than 100 meters or something. We were basically just over the landing strip – not a minute later we touched the ground. (I remember I was curious about our altitude earlier because the plane started braking (slowing down using its wings) in the middle of the thick white milk soup we were in, and there is no reason to brake in the air unless you are preparing to get onto a landing strip, right?).

Amsterdam airport is huge. Fortunately since I was there earlier with my boyfriend, I knew the exact path – I could even recall the stores that I was passing by. I got to the Plaza, where the train platforms were located. I bought an apple juice – it’s so weird, Dutch people don’t really have 0.5l bottles of juice, it’s either water or soft/soda drinks or some “sports” drinks (there are some but not a huge variety like in Poland) (well, except for this dreg-filled “healthy” varieties that were available in a fridge next to the eating-ready sandwiches). Even weirder was the cash desk: there was a display for the customers, but the cash desk wasn’t self-service at all – there was a terribly bored and uninterested in anything that was going on around her lady standing on the other side of the desk. Also the credit card reader wanted me to do some stuff, not just take my money – I think I was supposed to tell it whether I want a receipt or not. The bored lady finally helped me with that, though.

I found the correct train and Boud fetched me from the Deventer station. I am always terribly shy the first day, so the whole journey from the station to his house was completely dead silent. My brain wasn’t silent, but I usually don’t see a good reason to voice anything when I’m at that state.

When we entered the house, Irina and Wolthera were already there, waiting for us.

Fast-forward, because the rest was probably boring since I don’t remember anything. I got a new laptop. It’s pretty – all shiny and metallish – quite powerful, has HDR and a stylus to draw on the screen. Which means I have everything I need to develop Krita. I can check how well Windows Ink is doing. Also Windows put all the HDR on its head in some recent updates and everything I learned about Windows settings and their relationships to HDR in Krita is reversed now. It made sense before, but I guess Windows guys wanted to make it smarter and bind the standard brightness slider to the SDR brightness, and they did it… by binding it to the reported maximum number of nits… which obviously causes trouble in Krita if you use any brightness setting except for the lowest one. I still need to test it on my home HDR setup since Dmitry claims that it’s all caused by brightness buttons on the keyboard. I strongly disagree, but without the facts, I cannot say for sure.

Windows sneakily forced me to use the Microsoft account – I am so used to Linux Mint LiveUSB installers needing network to download everything that I didn’t think twice before I put the WiFi password in the textbox in Windows installer, and then it wouldn’t allow me to make a local account no matter what we did – turn off the WiFi, hard reboot the laptop, try to undo…

Somewhere at that point everyone was eating lunch: not sure what everyone had, but I remember Wolthera eating those weird things with liquid minced meat. A Dutch special, no doubt. No idea how they make it liquid; it looks a bit as if they were making some kind of bechamel sauce with minced meat and using it as stuffing for various foods. I just ate my boring ham sandwich I had made the previous day for myself.

Then Dmitry arrived. He brought gingerbread cookies for comparison, so naturally Irina and I took our cookies out as well. My cookies were very dark, thin and crunchy, cut into normal cookie cutter shapes (cats, pigs and hearts bought in OpenLucht Museum in Netherlands, spaceships that haters say are Christmas bells, snowmen, and some little humanoids) (recipe here: Gingerbread cookies); Dmitry’s were the most beautiful, cut into various shapes relevant to painting and Krita: pens, pencils, styli, Linux’s penguins and Kiki’s faces with her famous ears (same recipe, but he mixed his spices himself and he made them thicker and with more baking soda). Irina had made ginger cookies, not gingerbread ones, cut into circles (recipe here: Irina’s Ginger cookies).

There was lasagna for dinner. I don’t think I’ve seen any layers in it and the meat was in liquid form again (although different! not bechamel this time), but it was tasty, so I won’t complain 😉

To finish off the culinary stuff, the whole evening I was exploring Dutch “lemonades” that have nothing to do with lemons. There was anis seed lemonade and pear lemonade, both which I tried, there was also citron something and mint ones, which I haven’t. There was also Irina’s handmade lemon lemonade, very sweet and sour at the same time, very tasty. All the other “lemonades” were more like a syrup that you need to dilute with water. We have something like that in Poland too, but it’s usually raspberry or briar (wild rose) which basically looks like coke, but it’s incredibly more healthy (although they still have a lot of sugar inside).

Dmitry “fixed” two bugs that day. The first bug was mentioned by Wolthera, about a brush delay – she showed the same brushes in Krita and SAI and how much slower those in Krita are. It turned out that of course there was a stabilizer turned on…

The second one was mine, about HDR. I turned it on on my laptop and some time later, my laptop went to sleep and when it woke up, it was all white – every bright color became white, every not bright color became brighter. It had still constrained nits according to what SDR should show, but the colors were all wrong. And here, too, Dmitry figured it out – it turns out my laptop turned off HDR when unplugged, and since it’s all new etc., it went crazy during sleep. I unchecked the “disable HDR while unplugged” and put my laptop to sleep again and it all fixed itself.

Another terribly important and incredibly nice thing that happened to me that day was that I got two duvets to sleep under. Of course I had my hot water bottle in the suitcase as a last resort, but it’s always better not to need it. The room was also nice – the bed was higher up under the ceiling, with a ladder, and the view outside the window was quite surreal. There was a big flat roof of a tenant with grass on it, and around it there were triangular rooves of other tenants, one floor higher than the flat roof tenant. On the right there was additionally a big tree, a bit higher than all the tenants.

Unfortunately I forgot to make a proper photo of it when it wasn’t way too dark or raining. That’s a shame – considering the next Krita Sprint will be in Rennes, I’m not sure if I’ll be able to fix that terrible mistake. Oh well, that’s what painting is for – recreating all untaken photos.

Day 2

Next day I woke up quite early just to run head-first into another cultural shock. It turns out that the typical Dutch breakfast is… sweet. Which means their typical breakfast sandwich is a piece of bread, butter and chocolate sprinkles (btw chocolate sprinkles were different from the Polish ones, too: ours are smaller and more crunchy, theirs were, I think, actually made out of chocolate and they melted in my mouth instantly). There was also weird Nutella-like cream, quite light in color but with darker cookie bits mixed in. I don’t remember all the choices, but I know there was also honey and some other weird sweet paste. All of it was to be put on Irina’s hand baked bread.

(Me having Nutella sandwiches the previous day is not being a hypocrite, but a very notable exception caused by both a lack of sleep and early getting up – it’s hard to eat anything at that hour. Also I’m talking about general trends in society, in Poland, the general trend in society is to eat ham sandwiches or fried eggs, or something similar, definitely savory, not sweet).

We went for a walk and, since the lunch time started to creep in, we bought some lunch items in the Tea Room. Other people took pastries with cheese or this weird liquid minced meat inside, I chose a bread roll with some vegetables and cheese on it. The bread roll was phenomenal, if they had only fixed the ratio between a very intense tasting vegetables/bacon topping and the bread roll, it would have been perfect – but since there was more topping than bread, it was a bit too intense for me.

Dinner was simple but fashionable – halves of peppers with minced meat inside (the solid one, not liquid, fortunately). It was tasty, and the bread roll that was served alongside it was quite interesting – a huge flat surface, surprisingly soft, especially if someone saw this kind of shape only in Georgian bread.

I got a cup of hot chocolate. This is remarkable because I’d got a promise to get a hot chocolate from Boud long time ago, in April or March, and from now on, we’re even. (At least for hot chocolate. Someone promised me pancakes from cast iron pan for breakfast… 😉 ). The hot chocolate was nice, although it kind of seemed more similar to just a standard cocoa drink (milk + cocoa powder + sugar) both in taste and consistency than I expected. It did have however this cozy feeling to it that proper hot chocolate should.

I found another bug that Dmitry later “fixed” just as easily as all the previous ones. So as I said about Windows, it messed up all the HDR settings, or at least they were different from before. After some time, I noticed artifacts in my Small Color Selector (the only HDR-enabled color selector). I also noticed that Dmitry’s color selector looked different for the same nits and hue values – but I brushed it off. The artifacts were important though. It turned out that Windows reports different maximum nits values for different brightness levels, which messes up Krita completely (and is contrary to/not mentioned in specification). To fix the artifacts, one just needs to lower the brightness to minimum… (Dmitry says it’s probably a bug in IntelHD drivers that was exposed by Windows doing weird things).

Later in the evening we had a very nice discussion with Dmitry about Russian and Polish translations of various books and movies – Alice in Wonderland, The Jungle Book, Winnie the Pooh etc., especially the translations of names and gender. In the meantime, Boud, Irina and Wolthera were mysteriously whispering in Dutch behind a closed door… gossiping about us, no doubt 😉

Day 3

I haven’t eaten anything for breakfast that day. As soon as I went downstairs, there were new people in the living room – they were expected, of course, but I didn’t expect them so early. I tried to both follow the conversation and do my own things. But as soon as Wolthera came downstairs, we went for lunch.

We went to that really nice Dutch restaurant where my favourite-Dutch-person-that-I-don’t-know-a-name-of was a waitress. (I’m not sure what I like about her, but I think it’s her wide smile and a generally expressive manner). I ordered three eggs with cheese and ham. It was two slices of bread put together on the plate so that they made a circle, then on top of that slices of ham, then three eggs, then slices of cheese, all fried together on a small frying pan so it was shaped into a circle, too. Unfortunately, this amount of ham and cheese took all of the flavour of eggs away and the dish was overall a bit too greasy for my taste. The bread was delicious, though.

I left all of the talking to talking professionals. (My boyfriend said I can’t write “I left talking to professionals” because that would be diminishing myself, as if I wasn’t a professional. In Polish the phrase is used so frequently, often as a half-joke, that it wouldn’t be considered dismissive towards one, I think). I was listening to the bits about neural networks, but that’s all. Fortunately Dmitry is much more interested than me in using special super powerful CPU instructions to make Krita even better in terms of performance.

Dinner was in an Indian restaurant. I ordered my most beloved chicken biryani and made sure that garlic naans were ordered (ok, Wolthera made sure. Her memory is not terrifying, it’s useful). Naans were delicious, different from most of those I’ve eaten (they are usually less soft and have less sugar – I could clearly taste sugar in those), but great. Biryani, however, was… mediocre. They put peas and carrots in it. I’m not against vegetables in general, but those peas tasted as if they weren’t fried or anything, so their raw taste didn’t match the rest of the biryani at all. If they wanted to make it more healthy, they could have made vegetables go into a side dish… but I got a side dish too, with eggplant in some sauce. I will never understand what cooks see in eggplants. Every time you want to use an eggplant, you should take courgette (zucchini) instead – it has a milder, sweeter taste and doesn’t have this bitterness to it.

People that we met were really, really nice. One of them constantly tried to hire me to paint a family portrait for them. I have a job and since art industry is very competitive, I guess it would be better if I wasn’t stealing their jobs all the time 😉 And the next day the plot twist happened, it turned out that we had been talking about oil or acrylic painting. Well, I’m definitely not the right person to go to, then.

Day 4

For breakfast I ate a slice of bread that Irina baked with butter. It was too early for real breakfast and way too early for a Dutch one (we had to be outside of Boud’s house at 7:15 am – I had full 4h of deep sleep, which is enough for me to be operational). On the train I found a sweet bread roll in my backpack that I had forgot about. I had been given it on the airplane – a real traditional Polish sweet bread roll with sweet pudding filling. I love them. There was unfortunately only one, quite small and squeezed from being in my backpack, so I couldn’t share and show my companions they should love them, too.

There was catering for lunch. Quite different from what I’ve seen in Poland – there was Indian food, for example. I took some chicken in sauce with rice. It was great and the chicken was softer that I thought possible (the exact opposite of what we can get from the Indian restaurant next to my house – it’s all tasty, but the chicken is always bone-dry). It looks like Indian cuisine that doesn’t include spiciness is always delicious. I also liked the way it was served – there were those little bowls, I could take rice and chicken in all the proportions I wanted, and since the bowl was small, when I took only a bit to taste it, I looked stylish and fashionable, not picky 😉

After lunch I noticed Wolthera holding a cup with some yogurt and stuff. It turns out that dessert was being given out by a mysterious magical lady walking around. She’d appeared out of nowhere, had given Wolthera the cup and disappeared just as quickly. Fortunately some time later I found the magical lady on the other end of the corridor, caught her and took my prey. I think it might’ve been a frozen yogurt with a meringue on top, or maybe just yogurt with meringue, hard to tell, but it was yogurt (forest fruit flavour) and it was cold. And tasty.

Around 3 pm Boud decided to come back home. Dmitry wanted to stay to attend one more talk, Wolthera was as tired as Boud if not more, and I started to feel bored next to our booth and not rested enough to try to keep up with talks. It was a bit unfortunate because I didn’t find time to talk with The Smiliest Dev – well, she calls herself The Littlest, but I usually just assume I’m littler than others, so I think she might be wrong in her assessment. Or I am wrong. I should’ve asked her what height she is. My description is based more on my own perception, and what I was seeing was mostly her wide smile and beautiful hair. Ehh, well. Maybe another time.

When we were coming back from the conference, me leading two zombies or, alternatively, me being led by two zombies – how did we arrive safely that day, honestly – I was bravely fending off accusations of not having anything to eat. My backpack is nearly as magical as that lady, it always has something to eat. Wolthera was merciless, though. It turned out a package of M&M’s is not food. Cookies type 1 are not food, muesli bar is not food, chocolate bar is not food, cookies type 2 aren’t food, and basically I didn’t have any food, according to her. I wonder if my sweet roll would be considered food. Since Wolthera is Dutch, I don’t take her judgement in that department too seriously – I mean, they have liquid meat after all. (When Indians rant about mild food, I can smile and tell them I just prefer when my delicious food doesn’t cause pain; for Dutch I can only have some kind of ethnographic curiosity).

For dinner I had another Indian rice and chicken in sauce. Irina’s home made though, not catering. A different kind, still tasty, and I could put some crunchy stuff on top so it had a bit of a different texture. There were also slices of raw cucumber. It isn’t a combination I would make – see, Dutch are weird in terms of food – but it wasn’t bad at all. And at least it wasn’t inside the rice meal as they did in the Indian restaurant with peas and my biryani.

I got some Dutch waffles to take home. Those round flat waffles with caramel inside. They are quite nice; moister than the regular ones that my mom sometimes makes.

Day 5

As sprint days go, this one was very quiet. Boud was meant to talk with me about my TODO list, but looked super busy with his keyboard, and at 11 am he and Irina went out not to come back until after I went to the airport. Dmitry was quietly working with his new laptop at first as well, although later he convinced me that using Ninja would be a great idea, which it wasn’t. So I volunteerily broke my build (well, technically, install. It was complaining about some missing libraries). Wolthera woke up (or at least went downstairs) after, I think, Boud and Irina went out, not a problem since she was staying there anyway, and was – as you can guess – quietly doing something on her laptop as well.

Painting of a desert I've made that dayPainting of a desert I’ve made that day

Dmitry went home around 1 pm, that left only me and Wolthera in the house. She offered to bring some lunch for us. And coffee beans (I think it was beans), because the express run out of coffee and there is no way for Wolthera to start a day properly without coffee. Lunch was nice, two different kinds of pastries.We wanted to heat it up in the oven, but all of our attempts to turn the oven on failed miserably (it’s worth noting that my participation was mostly looking at the oven with an understanding smile and “oh, yeah, so that piece of technology, that’s the oven, that’s how you call it, okay, I see it has some buttons and knobs, oh yes, just as ovens should”). The pastries were good even cold, though. One of them was a thing that looked like a hotdog, but it was minced meat inside a thin, but layered multiple times, weird dough that looked like it was fried (and the minced meat wasn’t liquid!); and a pizza-like dough with pizza-like tomato based stuffing.

Much more interesting is what Wolthera brought for dessert. She said those are cookies that are made or sold around this time of the year, typical for Dutch and seasonal. Of course I had to try them – little chance I will be in the same country around the same time of the year, unless Krita employment really requires a yearly EU flights ticket.

They were delicious. I’m including a photo of the package just in case you have a chance to be in Netherlands in autumn. Those are very little, perfectly round and rounded cookies with some spices (Wolthera said later that you can buy the spices mix in Netherlands, but I didn’t know at that time and didn’t buy it). Tastes a bit like gingerbread cookies, but differently. Hard to tell, because those cookies were additionally covered in white chocolate and a generous amount of cocoa powder. Spices in the cookies, sweetness of the white chocolate and bitterness of the cocoa powder create a unique and incredibly good taste. (Of course I decided to steal the idea and try to make them at home, I already bought white chocolate).

Truffel kruidnoten package

On the airport I went to the same Albert Heijn store I had been to on Monday. I looked through all the sweets shelves (they have 1kg M&M’s packages!) and finally found one with something similar to the cookies Wolthera had showed me, I had no idea you could buy them without chocolate and cocoa powder… It turned out you can. There were other kinds, too: just cookies; cookies with white chocolate; cookies with milk chocolate; and then, finally, at the very end of the shelf (I had to reach deep inside) I found the white chocolate + cocoa powder (“Truffel”) ones. I was already worried about the weight of my luggage, but 250g more wouldn’t hurt, would it?

After a quick and very unhealthy dinner I went to the check-in. I was pleasantly surprised when they told me not to unpack my stuff – neither electronics nor liquids. I was much less pleasantly surprised when it turned out that every luggage with a laptop is stopped to be manually checked. Not unpacking didn’t save me any time after all… After I dealt with check-in, I only had 10 minutes until the gate was supposed to be opened.

Supposed to, because planes aren’t the most punctual in the world. I had to wait 40 minutes more. And the plane was different from what it supposed to be, so I didn’t get the seat next to the window. I wasn’t that disappointed because it was already dark outside. Landing in Warsaw was beautiful though – very thick fog with lights and industrial structures looked really amazing, mysterious – just like this indie game called “Inside”.

It looked interesting

On the plane I was mostly drawing on my new laptop – I noticed one flaw of our HDR demos, basically there was nothing that would show both super bright and super dark colors so that the dark areas still had details in them. I decided to fix it immediately. Some kind of an intermediate result below (the tree is way too big for the little river I started painting in the valley, but it is bad in more ways than one so it’s gonna be deleted as soon as I open this image to continue painting):

Unfinished painting of a sunset, made ion the airplaneUnfinished painting of a sunset, made ion the airplane (HDR, squashed to SDR afterwards)

(also: KItinerary + Browser Integration = <3)

KDE Itinerary is a project to get your travel itinerary presented to you in a unified, well structured and always up to date fashion, by extracting structured data from emails, boarding passes, and other sources. I successfully traveled the world with it!

Step 1: The crazy idea, is it viable?

Itinerary Research extension showing popup of structured data found on a restaurant website“Itinerary Research” extension showing what it’s found

Since I’m always looking for new innovative features to add to Plasma Browser Integration, having KItinerary not only look at your emails but also websites seemed like a natural evolution. During the Nürnberg Megasprint™ in June I pitched the idea to Volker Krause and he talked me through how all of this structured data and boarding pass magic worked. I then wrote a quick and dirty browser extension that scanned your open tabs for any such annotations, so we got a sense of how common they actually are in the open web.

It turns out: very. It is of course in a website’s own interest to add those attributes for higher ranking in search engines as well as richer and more useful search results. This got me very excited but unfortunately I didn’t come around to working on it any further until Akademy. Also check out Volker’s blog post for more infos on our little research effort.

Step 2: KItinerary groundwork

Fast forward two months and during Akademy Volker and I met again. This time he showed me how KItinerary builds a sanitized data structure off the various sources it can process, such as PDFs, HTML, pkpass files, and so on. Now that Plasma Browser Integration gained a toolbar popup in its latest release, my idea was to add some useful actions and details there about the contents of the currently viewed website. Volker suggested to focus on Hotels, Restaurants, and Events.

In order to keep KItinerary from becoming a giant over-engineered mess entity types and attributes are added only as they are actually encountered in the wild. This meant that at this point it could only deal with reservations (e.g. a boarding pass is a “flight reservation”, which is typically what you get in an email) but not actual establishments like hotels or restaurants. Once that was fixed, I checked random restaurants and hotels in the vicinity to get some actual test cases. Thanks to Carl Schwan, our website guru, we also got machine-readable event details on our own Akademy 2019 page!

Step 3: Making it happen!

Itinerary browser popup showing detailed information about Akademy 2019Plasma Browser Integration showing details about this year’s Akademy, extracted from our website

KItinerary comes with an external extractor binary which was added so 3rd party projects can use it without having to link against it. When a user clicks on the toolbar popup, the HTML of the currently viewed website is sent to the extractor process which then does magic and returns a normalized JSON structure I can then pour into a (for now pretty crude) user interface. Depending on the type of entity and data available I show things like start and end date of an event, the address of the venue, as well as contact information. The most useful part would of course be using KDE Connect to send the dates to your KDE Itinerary Android app (get it on F-Droid or directly from us), giving the organizers a call, or just adding the event to your calendar.

Itinerary browser popup showing detailed information about a restaurant, with "Reserve now" buttonSome random restaurant I found which features a “Prenota un tavolo” action

A website can even add custom “potential actions”, such as a direct link to a booking page, or their own internal search page. Once we get a date and time picker control in Kirigami we could then send the restaurant information to Itinerary and let you enter when you’re actually going there.

I also wanted to show a little indicator when there’s something interesting on that website but I surely didn’t want to fire up the whole extractor all the time. Instead, a tiny JavaScript is executed on the page as you change tabs which quickly looks for all itemprop attributes and JSON-LD tags to see whether there is actually something worth processing.

Indicators that interesting stuff was found (event, restaurant, hotel)Indicators about interesting contents (event, restaurant, hotel)

For now it’s just a crude badge using a fitting Emoji, including the one for “Hotel” which looks more like a hospital :-)

As an additional gem I wanted to be able to process tickets viewed in the browser’s internal PDF viewer as well, since if you get your boarding passes as PDF download the browser will probably just display it internally. Moreover, if you then download such a file it will also offer to add it to your KDE Itinerary.

Viewing a boarding pass PDF in the browserViewing my boarding pass to the Plasma Sprint in Valencia with a convenient Plasma Browser Integration popup

Step 4: You, giving it a try!

If you want to give it a try, you need a recent git master build of the kitinerary library. See also the troubleshooting guide, which also comes with instructions on how to build the optional image recognition feature needed for reading barcodes inside PDF files using zxing library.

For the browser side of things, check out the itinerary branch of the plasma-browser-integration repository and follow the “How to install” instructions from source code on its wiki page. Once up and running, visit your favorite event, restaurant, and hotel sites and see if they have any structured data we can process!

You might also want to build the kitinerary-workbench repository which contains a developer tool that lets you inspect the extractor output. Just paste the URL of the website you’re interested in, change the “source type” to HTML and compare what the “Extractor” tab says to what the “Post-processed” tab says. The contents of the latter is what the extension ends up showing in the popup.

I would also really appreciate some input from a dear reader more knowledgeable in web stuff than me! :-) The UI code for the popup is quite awful right now and really predestined for using some sort of HTML templating engine instead. However, I surely don’t want to pull in megabytes of third party JavaScript code just for a few conditionals and populating divs with dynamic contents and applying some pretty locale formatting.


November 01, 2019

Who do you think should be a Qt Champion? Nominate the champions you know right now!


Akademy is the annual world summit of KDE. This year I did GSoC at KDE and hence, got the chance to attend to Akademy, 2019 in Milan, Italy \o/This was my first trip to Europe and I was super excited about it!I traveled to Milan with my friend Piyush Aggarwal who is also GSoC 2019 student at … Continue reading Trip to Akademy 2019: First Impressions


As mentioned previously we have been looking at organizing a sprint to define the goals for KDE Frameworks 6. We now have a date and time for this: November 22-24, at the MBition office in Berlin!

What is this about?

The goal of this sprint is to determine what we actually want to achieve for KF6 beyond just porting to Qt6 and dropping deprecated stuff. We have already collected a number of ideas on the KF6 Workboard, but a lot of this is still very high level and could use a much more detailed analysis and breakdown.

To make the sprint as effective as possible, please keep adding topics to the workboard. Of particular interest are of course changes that we can only effectively do with an ABI break, where the KF6 transition is thus the only opportunity in a multi-year period. Besides API fixes or modernization this could also cover things like:

  • Separation between abstraction and platform implementation.
  • Decoupling from a specific platform or implementation (e.g. making things relevant for mobile usable without QtWidget dependencies, or reducing D-Bus use outside of Linux).
  • Close ties to legacy technologies (e.g. our emoji code stuck at pre-Unicode emoji times).
  • Non-ideal class locations (e.g. a very widely used class being in a high-tier framework).
  • (Desktop) UI code where it shouldn’t be (e.g. implicit error handling with message boxes).
  • Components that are only still around for historic reasons and meanwhile has been superseded by newer code in e.g. Qt.
  • Second class QML bindings that could benefit from moving to their corresponding framework.

Identifying the specific places we need to look at for those (or other) considerations would be very helpful.

Should I join?

If you are asking yourself this question the answer is most likely yes :)

In particular this is relevant for:

  • KDE Frameworks contributors.
  • People working on non-Linux and/or non-desktop platforms.
  • Application or workspace developers making use of KDE Frameworks, or wanting to use KDE Frameworks.

The latter is particularly important in my view, as Frameworks are pretty pointless if they aren’t support the applications people want to build with it. Or the other way around, this is a good opportunity to influence the platform you build your applications on.

And if you know people you think should be there, please help to spread the word and encourage them to participate!

How do I join?

Subscribe to the KF6 Sprint task on Phabricator and add yourself to the sprint wiki page. That’s also where you find information about the location, suggested accommodations, times, travel cost reimbursement, etc. as soon as they become available over the coming days.

Thanks!

Meetings like this are immensely productive and help us making big steps forward. They are however only possible thanks to logistical and financial support, which in this case we are getting from Akademy sponsor MBition in form of the venue and by KDE e.V. for the travel cost. If you want to help with such activities in the future as well, providing venues for sprints is always welcome, and so are donations to the KDE e.V. of course!


The Plasma Mobile team is happy to present the fifth weekly blogpost. This week’s update features various application polishing, better integration with GTK/GNOME applications and various fixes.

Shell and user interface

Nicolas Fella simplified the code of dialer and lockscreeen.

breeze-gtk gained support for libhandy widget style make them better resemble the style and look-and-feel of Plasma Mobile. In postmarketOS a patch was added to hide the close button in headerbar of GTK/GNOME applications.

GTK apps without headerbars

Applications

Jonah Brüchert fixed Plasma Camera to display the proper symbolic icon in the global drawer..

MauiKit

The inline notification dialog in applications now has a dedicated button to trigger a response action instead of having to click the popup to perform such actions, which was unclear.

The flickable ToolBar now has edge shadows to indicate that the content goes beyond the border and can be flicked.

Index

Components like the FileBrowser, used by Index and also by the FileDialog component, have been improved: the search now works as expected by also looking into the filename’s suffixes. On abstract locations like tags:// or applications:// the search now works by filtering the content. The preferences like “sorting order” are now correctly saved per application using these components.

Tags view

The FileBrowser has been cleaned up visually. The configurable options have been moved to its own configuration dialog.

Configuration dialog for Index

The Places sidebar now auto-refreshes when new tags are created.

You can open a path-bar path in a different tab.

Menu items have been better organized and now have icons

VVave

VVave now makes use of URL structures instead of strings to better identify local files from remote ones, this is some initial work in order to support streaming from remote locations.

Many parts have been moved to loaders to improve the performance and launch time by only loading them when needed.

The artwork is now once again correctly fetched from online sources, and the delegates are updated once new artwork has been found one by one, instead of reloading the whole set.

The main playlist sidebar no longer overlaps other content, like menus and dialogs.

VVave playlist

The tracklist and album grid delegates are using MauiKit item delegates for better visual integration with the other apps.

The floating disk is back, and it indicates a track is playing. By clicking on it the main playlist is revealed.

There is a new dedicated “focus” view which hides unnecessary controls.

VVave focus mode

For a better experience tracks are now added and start playing once you tap on them, instead of just appending them to the main playlist.

The selection mode now works like it does on Index, you can select multiple tracks and the selected state is preserved.

Selection mode

Finally, VVave can now stream music files from the NextCloud Music app. You just need to set up a valid account and the tracks will appear under the Cloud view. This is still a work in progress.

Cloud integration

Upstream

Jonah Brüchert started upstreaming the patches to port the ofono-phonesim to Qt5. The QR-code scanner application qrca and OTP client application Keysmith are now moved to the KDE namespace instead of their personal namespaces.

Want to be part of it?

Next time your name could be here! To find out the right task for you, from promotion to core system development, check out Find your way in Plasma Mobile. We are also always happy to welcome new contributors on our public channels. See you there!


October 31, 2019

Halloween was the perfect occasion for me to hack together a dark theme for more KDE websites. So now a dark theme version is also available for kde.org and planetkde.

It is using prefers-color-scheme: dark media query so it’s only available if you browser prefers the dark theme version.

KDE.ORG dark theme

Planet kde dark theme


We have released Qt 5.13.2 today. As a patch release, Qt 5.13.2 does not add any new functionality but provides many bug fixes and other improvements.

Compared to Qt 5.13.1, the new Qt 5.13.2 contains more than 200 bug fixes. For details of the most important changes, please check the Change files of Qt 5.13.2.

Qt 5.13.2 can be updated to existing online installations by using maintenance tool. For new installations, please download the latest online installer from the Qt Account portal or from the qt.io download page. Offline packages are available for commercial users via the Qt Account portal and at via the qt.io download page for open-source users.

As earlier update to Qt for Python will be available soon after Qt 5.13.2 release so stay tuned...



Older blog entries