Chromecast devices in the sound settings

This morning, while browsing the web, I wanted to listen to a Podcast from my laptop, and thought “Hey, can I stream this to our stereo?”. As it turns out, that’s rather easy to achieve, so I thought I’d share it here.
The media devices in our home are connected using Chromecasts, which are small dongles that allow playing media on them, meaning you can play for example a video from your phone on the projector in the living room: very convenient.

I didn’t know if that was easily achievable with audio from my Plasma/Linux laptop and a quick search turned up “pulseaudio-dlna” which adds Chromecast devices on the local networks as output devices.

On my KDE Neon laptop, it’s as easy as installing pulseaudio-dlna from the standard repositories and then starting “pulseaudio-dlna” from the commandline. Then, I can pick an output device from the panel popup and the audio stream changed to my stereo.

$ sudo apt install pulseaudio-dlna [...] $ sudo pulseaudio-dlna [...] Added the device "Stereo (Chromecast)". [...]

The KMyMoney development team today announces the immediate availability of version 5.0.8 of its open source Personal Finance Manager.

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

Besides the software itself, the KMyMoney website was refurbished and now has a more modern clean look. Thanks to all who were involved in the process.

The details

Here is the list of the bugs which have been fixed. A list of all changes between v5.0.7 and v5.0.8 can be found in the ChangeLog.

• 326212 Editing split memo when there is only one split does not update the record memo
• 361865 In German, the dialog uses “share” if it is actually shares and/or bonds (i.e. securities).
• 395052 No documentation available for csv exporter
• 398982 Opening Balances in forecast are wrong
• 399364 SKR03 account template does not contain a flag for an opening balance account
• 406403 Tags within Split transaction not reporting correctly
• 411015 Investment doesn’t show correct value after switching investments
• 412429 No display of transactions in the tags view when tags are specified in a split
• 413325 Problem with Web addresses at financial institutions
• 413555 Reconciliation of Credit Card
• 414333 Investments – Edit and New investments – Unable to display online source list for Finance::Quote
• 414932 Incorrect “opening balance” in daily and weekly “Investment Worth Graph”
• 415257 Changing status of an investment transaction clears bank ID
• 415409 False detection of a matching investment cash dividend transaction
• 415548 The character < as part of a matched transaction which was imported causes load to fail
• 415668 Networth by month shows incorrect values for investment
• 415793 Creating multiple tags in a row does not correctly adjust the name
• 416052 AppImage is missing the account/category templates
• 416269 Changed name of loan account is not saved
• 416274 Investment reports show incorrect annualized return percentage
• 416410 Add a recuring transaction – loss of input if we forget the source account

Here is the list of the enhancements which have been added:

• 415411 No support for check forms with split protocol

Hello all!

This is a series of blog posts explaining different ways to contribute to KDE in an easy-to-digest manner. This series is supposed to run parallel to my keyboard shortcuts analysis so that there can be content being published (hopefully) every week.

The purpose of this series originated from how I feel about asking users to contribute back to KDE. I firmly believe that showing users how contributing is easier than they think is more effective than simply calling them out and directing them to the correct resources; especially if, like me, said user suffers from anxiety or does not believe they are up to the task, in spite of their desire to help back.

This time I’ll be explaining how the localization workflow looks like for contributing to KDE; this should also immediately enable you to translate your favorite third-party Plasma widgets (if the project supports it), and generally allow you to translate any PO file with your preferred localization software. I will also explain a bit about CAT tools in general and how professional translation is done since it’s my field of expertise, but that will serve only as optional reading for those interested.

Don’t get scared with how lengthy this blog post is: by the end of this text, you should be perfectly fine to start working with localization, that’s the point. The localization process is quite straightforward, I simply put a lot of explanations in-between so you don’t have many (or better yet, any!) doubts about how stuff works.

This article should be timely in that a new Plasma version, 5.18, will be released in about two weeks. Contributions to the stable branch would be quite appreciated in the following days!

If you’re already acquainted with git, svn, Phabricator and KDE Identity or if you would simply like to skip the explanations, understand the CAT tool and go to the how-tos, click here.

If you think you already know enough of translation software interfaces and you don’t need to get acquainted with the default KDE localization tool, Lokalize, you can skip the explanation about its interface and work immediately by clicking here.

The KDE localization infrastructure

Currently, KDE’s infrastructure is divided between several places, which is something I particularly like.

We have bugs.kde.org for reporting bugs, phabricator.kde.org for discussion and patch reviewing, identity.kde.org for centralized account management, cgit.kde.org and invent.kde.org for active git repositories, github.com/KDE for a git mirror, etc.

To understand the KDE infrastructure, first we must understand a tiny bit about version control software.

Git is the most popular version control software, or so I’ve heard. Subversion, or SVN, is also version control software, and both serve as a means to store code and data in such a way that we end up having multiple versions of the data stored, meaning three things: one, if a specific version is problematic, it can be reverted, two, there’s always a backup/record of what was done, and three, multiple people can suggest changes for a new version of the software.

These suggestions are called commits and, if you’re a developer, such commits would go through a review as patches to the code. For translators, however, it works a bit differently: if you do not have the rights to send translation commits directly, it must be sent to either the mailing list or to a translator with commit rights through any means, such as Telegram, IRC or Matrix. If you do have such rights, you are an experienced enough translator who is also trusted by your more experienced peers. With this, your submissions will be available for everyone to see, and your task will be easier and faster.

Some websites provide a frontend for version control software, such as Github or Gitlab, whose names clearly indicate they handle git. KDE intends to migrate code handling to Gitlab, but SVN will still be used for translation and some other stuff.

Both repositories can be seen in Phabricator, which means any translation commit uploaded to git or SVN will show up there. Even if you don’t submit the commit yourself, the translator who submits it for you will be able to assign (and should assign) your name as the author of that commit.

You can see the SVN repository on Phabricator here, it’s just one of many repositories hosted by KDE: https://phabricator.kde.org/source/svn/.

In addition to Phabricator, another place that is relevant to translators is Bugzilla, which serves to report bugs. There is a specific section for managing translation issues, namely the i18n product: https://bugs.kde.org/describecomponents.cgi?product=i18n.

And yes, translation issues are also reportable bugs, as weird as that might sound for someone who is not acquainted with bug reporting. If a specific string of text (a segment, sentence or any amount of text in a sentence) is not in the target language of a given application or if it is incorrectly translated, you can report it to the localization team responsible for working on the translations into your mother language.

The reason the Bugzilla product is called i18n is because, long time ago, there was some confusion pertaining to how internationalization (i18n) and localization (l10n) were supposed to be handled. It is a complicated matter, one which I won’t adventure within in fact, but to simplify things I prefer to use the definition provided by Qt:

The internationalization and localization of an application are the processes of adapting the application to different languages, regional differences and technical requirements of a target market. Internationalization means designing a software application so that it can be adapted to various languages and regions without engineering changes. Localization means adapting internationalized software for a specific region or language by adding locale-specific components (such as date, time, and number formats) and translating text.

Quotation 1, Qt definition of i18n and l10n.

The important part here is that i18n is generally handled by software developers and l10n is generally handled by translators. These definitions may vary a lot if you search for them, though, especially considering internationalization and localization can easily be mixed together.

However, the i18n product in the KDE Bugzilla is a general place to report any issues pertaining to translation, including internationalization and localization issues.

The last important place we need to talk about (briefly) is identity.kde.org.

A KDE Identity is a common login which can be used on Phabricator, Bugzilla, the Wikis, Invent and some other places. There, you can apply for different kinds of account, among them a developer account, which is required for translators to commit directly to SVN.

Since a developer account provides commit rights, this is only provided by sysadmins to trustworthy contributors who have several public contributions and are referred by one of the main contributors in their specific field, which in this case would be a member of the localization team which you contacted and are collaborating with.

This may sound scary but it really is not. It is a mere formality, as long as you fill the two main requirements of referral and enough public contributions.

The first contact

The first thing you must do in order to start translating is contact the localization team responsible for the language you want to translate KDE software into.

The main, formal way of doing this is by subscribing to the respective mailing list and sending an email showing your interest in contributing, whereas the main informal way of contacting your team should be by IRC, such as the #kde-i18n channel.

A few teams, like mine (Brazilian Portuguese), have other means of contact, such as Telegram and Matrix, two different Instant Messaging software similar to Whatsapp and Discord, respectively. So if you’re unacquainted with IRC or mailing lists, you may contact your team this way. The KDE Community has a wiki for Telegram and a wiki for Matrix, which I’ll try to update later with Telegram/Matrix rooms I find.

Your localization team should instruct you both on how to start translating and on commonly-agreed terminology.

The first thing you’ll likely have to do is install three very useful utilities called Lokalize, subversion and kdesvn. Lokalize is the main Computer Assisted Translation (CAT) tool we’ll be using to translate KDE software; subversion allows us to download the files for translation, which are hosted through SVN and accessible through a web interface which you can see here: https://websvn.kde.org/; and kdesvn is a tool used by translators with a KDE developer account to easily submit any translated files.

The three main places we as translators should care about are as follows:

• https://websvn.kde.org/trunk/l10n-support/
• https://websvn.kde.org/trunk/l10n-kf5/
• https://websvn.kde.org/branches/stable/l10n-kf5/

The folder l10n-support contains folders respective to each language available to translate, and within each folder there are scripts, glossaries and other such things that are used by each team to ease the translation process.

The respective trunk/l10n-kf5 folder for your translation team contains two main folders of interest: docmessages and messages. This is also true for stable/l10n-kf5.

The folder docmessages stores the documentation for a given application, a.k.a. its respective usage manual, whereas the folder messages stores translation files pertaining to the interface of a given application; that is, text strings appearing in the application itself.

Docmessages have a few differences compared to software translation and the translator should at least know a bit about the documentation team and its workflow, so I’d recommend you start with the messages folder instead. It’s not that complicated either, though.

Both the stable and trunk folders may also contain some pertinent scripts or glossaries for quick access.

Trunk includes versions of applications that are still in development between major/point releases (such as 5.17.0), in addition to the www file, which pertains to KDE website strings; stable includes a specific version of applications as frozen in time (more specifically, a major release). Once trunk reaches a major release, its current state will be the new stable, and so it is of primary importance to translators; however, stable should also be a priority so that distro releases may benefit from translations. At this exact moment, the current stable will be used for the new Plasma 5.18, which makes this article quite convenient, as I might catch your interest in translating KDE software for this Long Term Support release!

The barebones

After that, the one thing you need to do is get the files needed for translation.

For that, you may first check on websvn for the correct folder you want. For instance, trunk/l10n-kf5/pt_BR/messages, the folder containing only interface-related files for Brazilian Portuguese, should show an SVN link: svn://anonsvn.kde.org/home/kde/trunk/l10n-kf5/pt_BR/messages. To download the entire folder, you may simply type the following in a terminal:

svn co svn://anonsvn.kde.org/home/kde/trunk/l10n-kf5/pt_BR/messages

And it should start downloading files into your home folder.

You can also just download the specific file you want from websvn and work on that if you want.

Likewise, you may also create a simple bash script for downloading your desired folders automatically, if you’re able to do so.

The files you just downloaded, as you will see, are PO files.

They follow a standard widely used in localization named GetText. Typically, translators would receive PO template files (those with a .pot extension), translate them and rename them as .po files. Many CAT tools also provide automatic conversion for ease of use. However, since we will translate incomplete files, we’ll likely not need to do such a conversion at all.

Let’s take a look on how a PO file looks. Here’s kontact._desktop_.po just as an example, since it’s quite short.

# Translation of desktop_kdepim.po to Brazilian Portuguese # Copyright (C) 2003-2016 This_file_is_part_of_KDE # This file is distributed under the same license as the PACKAGE package. # # Antonio Sergio de Mello e Souza <asergioz@bol.com.br>, 2003. # Lisiane Sztoltz <lisiane@conectiva.com.br>, 2003, 2004. # Lisiane Sztoltz Teixeira <lisiane@conectiva.com.br>, 2004. # Lisiane Sztoltz Teixeira <lisiane@kdemail.net>, 2004. # Henrique Pinto <henrique.pinto@kdemail.net>, 2005. # Eduardo Habkost <ehabkost@conectiva.com.br>, 2005. # Eduardo Habkost <ehabkost@raisama.net>, 2007. # André Marcelo Alvarenga <alvarenga@kde.org>, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016. # Luiz Fernando Ranghetti <elchevive@opensuse.org>, 2008, 2009, 2010, 2011, 2012. # Marcus Gama <marcus.gama@gmail.com>, 2012. msgid "" msgstr "" "Project-Id-Version: desktop files\n" "Report-Msgid-Bugs-To: https://bugs.kde.org\n" "POT-Creation-Date: 2019-07-22 01:21+0000\n" "PO-Revision-Date: 2016-04-06 08:00-0300\n" "Last-Translator: André Marcelo Alvarenga <alvarenga@kde.org>\n" "Language-Team: Brazilian Portuguese <kde-i18n-pt_br@kde.org>\n" "Language: pt_BR\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1);\n" "X-Generator: Lokalize 2.0\n"

This is the header section of PO files and it can be safely ignored: that section will be filled automatically for you later by Lokalize, as long as you fill your information properly.

#: src/data/kontactconfig.desktop:14 msgctxt "Name" msgid "Kontact Configuration" msgstr "Configuração do Kontact" #: src/data/kontactconfig.desktop:61 msgctxt "Comment" msgid "Default KDE Kontact Component" msgstr "Componente padrão do KDE Kontact" #: src/data/kontactconfig.desktop:108 msgctxt "X-KDE-Keywords" msgid "kontact" msgstr "kontact" #: src/data/org.kde.kontact.desktop:2 msgctxt "Name" msgid "Kontact" msgstr "Kontact" #: src/data/org.kde.kontact.desktop:73 msgctxt "GenericName" msgid "Personal Information Manager" msgstr "Gerenciador de Informações Pessoais"

The body section contains strings to be translated.

The first line shows which file contains the string we are going to translate, that is, the context of the string, which is useful to determine which component of the software contains that string; the second contains a generic name for that specific string.

The third and fourth lines are the ones that matter most to translators. The corresponding text for msgid, contained between quotation marks is the source text to be translated, and msgstr is the translated string that the translator enters.

Let’s see how it looks from within Lokalize. But first, let’s get acquainted with its interface.

The Lokalize interface

If you recall, we originally downloaded the required trunk files with svn co svn://anonsvn.kde.org/home/kde/trunk/l10n-kf5/pt_BR/messages. They will be found on your home folder, so in ~/messages, that is, /home/yourusername/messages. You can then go to whichever file you want and open it directly through Lokalize. But that’s not practical: there are, literally, hundreds of files to navigate to, and you don’t even know which of these is incomplete! That’s where Lokalize comes in. Here’s how it looks like when you open it directly for the first time:

Figure 1 – The Lokalize welcome screen.

If we click on “Configure Lokalize”, we’ll see the Settings dialog. Lokalize attempts to fill your Identity data based on the default language set up for your user, but it doesn’t always get it right, so it’s best if we fix it. Mine, for instance, came with kde-i18n-doc@kde.org as mailing list when it should be kde-i18n-pt_br@kde.org, as stated here. A simple peek on Google, DuckDuckGo, Searx, Ecosia or whatever search engine you prefer should show you the proper mailing list.

Figure 2 – The Identity dialog.

Alright, now closing the dialog, you may click the “Translate Software” button. It’s quite straightforward, and it works the same as going in the menubar and selecting Project > Create software translation project…

A new dialog asking for the location to create an index.lokalize file will appear. There, you can select the messages folder we downloaded before and press Save. This file serves to store your project info and will be opened automatically every time you start Lokalize, which is quite convenient.

On the next dialog, you just need to fill the Target Language field and the mailing list accordingly, then press Ok.

What you will see afterwards is something like this:

Figure 3 – List of files to translate without titlebar in order to fit into one screenshot and with the kdewebdev folder open.

Now we have all files perfectly sorted in alphabetical order and displaying the level of completeness of each folder and file.

If you have a keen eye, you may have noticed I focused the “Hide completed items” up above. Its very useful functionality allows the translator to pick which file to translate easily.

Figure 4 – List of incomplete files to translate.

I deliberately didn’t open the extragear and playground folders to mention a little something.

The extragear, playground and www folders are special. Extragear corresponds to any KDE software that do not follow the KDE Frameworks and KDE Applications release schedules; playground contains only KDE software that’s incubating, that is, software that has recently been added as part of KDE applications and is still being integrated. That’s the case with Subtitle Composer, for instance; the www folder isn’t related to software text, but rather contains all translatable text found in kde.org within the www_www.po file, such as the kde.org/announcements page, and as such it includes content which must be handled and reviewed with more attention, as it’s essentially the face of KDE. The latter is an ever-growing behemoth of over 10,000 strings—yeah, strings, not words or characters.

Core KDE software and www should receive special attention, especially when a new release is coming, but you shouldn’t dismiss other applications either. As a matter of fact, when contributing to something you like, you should be having fun. And I do mean having fun, choosing what looks the most interesting to you and working with what you would like to translate, at the very least initially. If you have seen a little mistake in the interface or somewhere in your favorite software, maybe fixing the translation should render that petite joy you might want on the specific day you started translating something.

Now, let’s finally take a look on how the interface for translating looks like. Click on any .po file you’d like; I’ll use subtitlecomposer.po as an example.

Figure 5 – The translation interface.

If you are already acquainted with Computer-Assisted Translation (CAT) tools, you might recognize most components on this screen almost immediately.

On the upper left section, Translation Units, you’ll see a list of strings available to translate containing lots of data over each string. The most blatant are the text and its corresponding translation state.

A green check mark icon indicates the string has already been translated; a purple question mark indicates a string that has some text translated but hasn’t been approved yet for some reason (fuzzy), and the gray X shows the string hasn’t been translated or edited yet.

A string marked as fuzzy is generally quite important. It may contain a note explaining any doubts you might have so other translators may contact you later or take into consideration when translating. It may simply be a string that has been moved somewhere in the application code and thus might be slightly different. It may also have been detected automagically by Lokalize because of another branch; say you’re translating a file on the stable branch and the string looks exactly the same as one that has already been translated in trunk, you’d get a dialog prompting you to check the corresponding trunk string, showing up as fuzzy for you to either change or accept. This is also true for similar strings.

Notice in Figure 5 the bottom left pane, Alternate Translations. The referenced translated string is “Check for errors in the current subtitle”, and the current string is “Clear detected errors and marks in the current subtitle”. Thus, the previous translation, “Verificar erros na legenda atual”, shows up automatically, so even if it is not correct, this at least means you don’t need to type the entire sentence for translation, only specific sections.

A better example of this can be seen in www_www.po:

Today KDE releases a bugfix update to Plasma 5, versioned 5.3.1. \n
Plasma 5.3\n
was released in January with many feature refinements and new modules to
complete the desktop experience.\n

Today KDE releases a bugfix update to Plasma 5, versioned 5.3.2. \n
Plasma 5.3\n
was released in April with many feature refinements and new modules to
complete the desktop experience.\n

Notice how the only thing that needs to be changed here is the months (January and April) and the version (5.3.1 and 5.3.2) . This feature is incredibly useful for automating the translation of www_www.po.

As for the other panes, Unit Metadata contains notes and the previously mentioned context of the string, that is, in which part of the code it is located. With the context, you can sometimes sort of guess where in the interface the string is, and so you can more easily verify whether your translation is appropriate or not.

If you click the “Add a note…” button, you can add a small note that should appear in your PO file as # Some note. See how it looks like if I edit this string, keep it fuzzy and add a note:

#This is a note.
#: src/application.cpp:673
#, fuzzy, kde-format
# | msgid "Check for errors in the current subtitle"
msgid "Clear detected errors and marks in the current subtitle"
msgstr "Limpar erros e marcas detectadas na legenda atuals"

The first line is the note itself. The third line includes the word fuzzy in it, indicating its fuzzy status. The fourth line starts with a |, which indicates the string referenced in a previous translation.

You can see a tooltip explaining the role of Alternate Translations by hovering your mouse over the pane’s titlebar.

The Translation Memory and Glossary panes are common to all CAT tools. Translation Memory works similarly to Alternate Translations, but only with strings that were translated by you ever since you started translating; it grows together with the number of translations you do. There’s even a tab in the interface dedicated to looking into translation memories.

The Glossary, also known as the Term Base, serves to store any terms you’d like to keep for future reference, with additional notes and whatnot. Depending on your localization team, you might have a shared glossary which you can add to Lokalize in order to guarantee a certain level of consistency between translations.

In the professional translation world, glossaries are quite useful for beginners and, well, forever, if well kept. Translation memories are nevertheless very well-regarded by highly-experienced translators (by this I mean several years, possibly decades), as all of the data they contain facilitate the translator’s job immensely. Another use for the Translation Memory is to contain only strings pertaining to specific subjects or to specific clients, which is quite desirable. You may have a dedicated translation memory that accounts for all documents pertaining to the internal management of a company, but it might contain specific terminology that only that client requests and that is not canon within the field; using such a translation memory could potentially be detrimental if you’re translating for another company insofar as you utilize non-appropriate terminology for that company’s documents.

Last, but not least, there’s the unnamed translation pane on the upper right. It’s no surprise at all: its upper section contains the source text, that is, the text to be translated, and the bottom section contains the target text, the translation per se. That’s where you’ll be working the most.

The translation workflow

Now that we’ve gotten ourselves familiarized with the interface of Lokalize, I’ll show you the default workflow for translating and a few tips by me.

For those who skipped this wall of text, you can download the files for translation using the method described in the beginning of this section.

After you’ve opened your desired file, you can select a string that hasn’t been translated yet and translate it. It is recommended that you keep the line size on the translated string similar to the source text, but it is generally a cosmetic change for better readability of PO files. Going forward with the explanation: if the cursor is on the last line of the translation, you can simply press Down to jump to the next string. Likewise, pressing up when you’re on the first line will send you to the previous string. The same can be achieved by pressing PgDown and PgUp, respectively.

The next string may already be translated, so other useful keyboard shortcuts are Ctrl+Shift+PgUp/PgDown, which go to the previous and next non-ready strings. Non-ready here means both untranslated and fuzzy, of course.

If you find a fuzzy string that doesn’t need to be changed, you may simply approve it; similarly, if you don’t feel like you want or is currently able to translate a specific term, you might want to translate most of the sentence and set it as fuzzy. In the toolbar just below the menubar and high above the Lokalize interface, you should see the Approved button. Clicking its arrow should allow you to choose which status to set as true for that specific string; clicking directly on Approved will approve the string. You can also toggle this state by pressing Ctrl+U. This only works when there’s text in the text target field, of course.

If you’re a minimalist and want to clean your interface and arrange it to make it as comfortable as possible, you can do several things:

One is right-clicking on the bar containing Source, Target, Notes, Context etc. on the Translation Units pane and deselecting whatever field you don’t want to display. Another is click-and-holding the corresponding titlebar for each pane and moving it. You can arrange them however you’d like, even relative to each pane; it’s an advantage of Qt applications, you see. This is the same with the proprietary CAT tool Memsource, also developed using Qt. You can also change the size of each pane like how you can resize windows in any application: by grabbing its borders.

If you have a multi-monitor setup, one thing you can do is unpin a pane from the interface by clicking the diamond icon to the left of the pane’s close button and put it on your secondary monitor. Removing panes you don’t find useful is also quite handy; in my experience, the Translation Memory pane hasn’t been very useful when localizing software even though I’ve used it periodically, so I often remove it.

If you think a specific string is worth future consideration, say, if you think a dubious translation should be reviewed after you translated the rest of the file or after terminology research, you may also press Ctrl+B to bookmark it. You can then later check the Go > Bookmarks section on the menubar.

Unlike other CAT tools (and similarly to Memsource), Lokalize doesn’t abstract tags by transforming them into icons; tags are kept as is, and in the case of PO files, they are usually html tags, such as in <b>Some string that is bold.</b>. For those used to traditional translation with professional CAT tools (as opposed to localization software), tags usually correspond to formatting (italics or bold, for instance) in .doc, .docx and .odt document files, and they surround the text that is modified by said formatting. Software doesn’t usually contain this kind of formatting though, which is why GetText is a standard that utilizes plain text.

Since Lokalize keeps tags as is, including multi-line links, it is kind of a pain to add them by copy-pasting. You may have the idea of copying the source text to the target text field with Ctrl+Space and then working upon that, but that’s not really convenient at all, now is it? Instead, you can use keyboard shortcuts such as Ctrl+T to add tags from a list, or Ctrl+M to add tags sequentially, that is, in a sequence based on which tag has already been added.

I strongly recommend that you explore the Settings > Configure Keyboard Shortcuts… dialog if you’re already used to some CAT tool, though. Setting the most used keyboard shortcuts to something you prefer or are used to is incredibly more productive than trying to learn a completely different set of shortcuts which are highly customizable. I tend to set Ctrl+Enter for jumping to the next non-ready string and Ctrl+Shift+Enter for the opposite direction, Ctrl+i for copying source to target and Ctrl+Up/Down for previous/next string. The three first ones come from Memsource, whereas the latter two ones come from Matecat.

One of the last things I should mention and that you absolutely must pay attention to are plurals. Let’s take a look on Figure 6 for a bit:

Figure 6 – Plural Form.

This was a mistake I made on one of my first translations.

Note that the sentence to be translated contains:

An error occurred while renaming %1 image.\n

Originally, I had translated it like so:

Ocorreu um erro ao renomear a imagem %1.\n

I know most people reading this post won’t know any Portuguese, so I’ll translate what I assumed the source text meant:

An error occurred while renaming image ImageName.\n

I hadn’t noticed the upper tabs mentioning Plural Form 1 and 2 on my first time. Additionally, I didn’t notice the lack of an article between renaming and %1, and it’s generally a silly error. For comparison, see how Plural Form 2 looks like for the source text:

Plural Form 1: An error occurred while renaming %1 image.\n

Plural Form 2: An error occurred while renaming %1 images.\n

This essentially means that, in the first case, the variable %1 stands for the number 1, and in the second case it corresponds to any number higher than 1, that is, anything that requires “image” to be instead plural “images”.

Variables are something unique to localization compared to other translation variants: they stand for text whose position may vary according to the context and language that it is being translated into. Translators should be quite wary of them. They are usually represented by some symbol (%, &, #, @) and a number.

Thus, in Brazilian Portuguese, the proper translations would be:

Plural Form 1: Ocorreu um erro ao renomear %1 imagem.\n

Plural Form 2: Ocorreu um erro ao renomear %1 imagens.\n

When one of the experienced translators of my localization team tried to upload my translation, he met with an error provided by a script that checks all PO files before proper upload. By verifying the error with the command msgfmt -c, he found out what the error was. The script noticed that Plural Form 2 was missing, and the command specified what string in what file had that error.

Out of curiosity, let’s check how it looks like on the PO file:

msgid ""
"An error occurred while renaming %1 image.\n"
"Do you want to rename this image again or rename this image by overwriting?"
msgid_plural ""
"An error occurred while renaming %1 images.\n"
"Do you want to rename these images again or rename these images by "
"overwriting?"
msgstr[0] ""
"Ocorreu um erro ao renomear %1 imagem.\n"
"Você prefere renomear essa imagem novamente ou sobrescrevê-la?"
msgstr[1] ""
"Ocorreu um erro ao renomear %1 imagens.\n"
"Você prefere renomear essas imagens novamente ou sobrescrevê-las?"

There are two things of note here: msgid_plural now exists and corresponds to Plural Form 2, and msgstr now contains [0] and [1], which are array notation used to correspond strings: [0], the first entry in a typical array, corresponds to Plural Form 1, the first form, whereas [1], the second entry in a typical array, corresponds to Plural Form 2, the second form.

This string also allows us to verify another particularity of PO files: multi-line text is shown below msgid/msgstr and after a “” in front of msgid/msgstr.

One last thing to mention is that, if you’ve followed this article and you installed kdesvn, you should now have a right-click entry on the KDE file manager Dolphin that is named “Update (Kdesvn)”. You don’t need to run svn co or svn up whenever you want to re-download your translation files anymore, you can simply go to the folder where you translated them, right-click an empty space and select the option “Update (Kdesvn)”. It should show a dialog mentioning it’s complete almost immediately, depending on your internet connection.

It is important that you always update your translation files before working on them, since during the time interval in which you’ve been away or not translating someone might have already changed the file you intended to translate. It’s no use working on an old file, you see.

Now, if you take a look on the kdesvn tool, you’ll notice how streamlined the interface is.

Figure 7 – The kdesvn interface.

It is incredibly useful for translators with proper permission to submit translations themselves: kdesvn detects the repository whose folder you open, organizes all files in tree view, highlights the folders and files containing changes, allows to update the repository quickly, and if you already have configured your environment, uploading only the files changed are a breeze. I know svn is quite old and most people acquainted with code will prefer git, but this fine tool that is integrated in Dolphin is precisely what made me like svn in the first place, and I am quite satisfied with it. If KDE ends up migrating the localization infrastructure to git in the (not near) future, I’d strongly appreciate a similar tool that is simple and easy to use even for people not that acquainted with repositories, as well as integrated to Dolphin.

Today will not be the day I explain how translators with permission can upload translated files, though. I still don’t know that much about the process, either, to be honest. So if you’ve finished translating a file, you may send it either directly to a translator with upload permissions or to the mailing list. Initially I sent my translated files to the Brazilian Portuguese Telegram group, and now that I have a developer account I upload files directly to SVN, though I’ve slacked with that in recent times.

To summarize

This was a fairly lengthy article, but it should clarify most things necessary and not-so-necessary for potential contributors to make their first step into localization involving KDE software. I wrote it so that it was quite comprehensive, but in practice the workflow isn’t complicated at all. On the first time, it boils down to:

• Download the files to be translated
• Create a project to list them easily
• Translate them
• Send them for upload

And after the first time:

• Right-click the file manager and update your existing files
• Open Lokalize (it opens the previous project automatically)
• Translate
• Send them for upload

And that’s not hard at all. In fact, from the second try onwards and aside from translation itself, the rest of the procedure is so easy and straightforward it ends up becoming part of muscle memory!

For the last bit of this post, I’ll add a few links for those willing to learn more or contribute.

Interesting links include the Get Involved wiki page for general contributing and the Get Involved Translation wiki page for a brief explanation on where to get more information; you may find the mailing list for your language in the links available here under kde-i18n or kde-l10n; you may also contact the general i18n team on IRC; if you’re Brazilian or speak Brazilian Portuguese, we have a Telegram group for you; if you’d like to translate widgets instead, you might wanna have a look at store.kde.org and search for the github page for the widget; most things related to KDE localization can be found on the official page, for instance the Translation HOWTO, which is an even more comprehensive guide than this blog post; and this online tool allows you to search already translated strings in KDE software, serving as an interesting translation memory that should even help in other fields. Some localization teams might be more approachable if they have a dedicated website for your country, such as fr.kde.org for France or kde.ru for Russia. If you’d like more information about translation on Linux, you may also be interested in checking TranslateOnLinux or a specialized distribution focused on translation called tuxtrans, made by an Austrian professor at the University of Innsbrück. If you’d like to know about other professional CAT tools, you may want to check the Proz comparison tool; some of the tools displayed there also run on Linux, either natively, using Java (like OmegaT, an open-source CAT tool) or through the browser.

A ton of features, bugfixes, and and user interfaces have landed for Plasma 18, and a beta release is now available for adventurous types to test out ahead of the release next month.

I think this is the Plasma release that a lot of people have been waiting for. It’s faster, more stable, more beautiful, and more feature-filled than any previous release, and it comes with a Long Term Support guarantee. Nothing is perfect, and we can always do better (and always strive to), but I think Plasma 5.18 is going to hit a sweet spot for a lot of people. Look for it in the next LTS releases of Kubuntu and openSUSE Leap, as well as all the rolling release distros of course.

New Features

• Screen auto-rotation now works on Wayland for computers with accelerometers (Roman Gilg, Plasma 5.18.0):
  
• The visual settings for GTK apps are no longer required to be configured manually and separately; instead, they are automatically synced from your settings for KDE apps – except for the theme itself, which can still be set separately because there isn’t a 1:1 mapping between KDE and GTK themes (Mikhail Zolotukhin, Plasma 5.18.0)
• The popular Thumbnail Grid Task Switcher is now shipped as a part of the kdeplasma-addons package (Chris Holland, Plasma 5.18.0)
• The System Settings Background Services page has been rewritten to for better looks and usability (Kai Uwe Broulik, Plasma 5.19.0):
  

Bugfixes & Performance Improvements

• JPEG thumbnails are now subtly sharper and better-looking (William Tradewell, Dolphin 20.04.0)
• System Settings no longer crashes when you click on the “Global Themes” item on the main page (David Edmundson, Plasma 5.18.0)
• KInfoCenter no longer crashes when you navigate between the Energy Info page and other pages (Harald Sitter, Plasma 5.18.0)
• The calculator applet no longer displays bizarre results for certain multiplication operations (David Edmundson, Plasma 5.18.0)
• Checkboxes drawn on top of images and selectable list items are now always visible (Noah Davis, Plasma 5.18.0):
  
• The feature that allows you to optionally set an image as the wallpaper when dragging it to the desktop now works with remote images in web browsers too (Tranter Madi, Plasma 5.18.0)
• Discover should now be more reliable at locating apps no matter what their AppStream ID is; for example Blender will be accessible from both blender.desktop and also org.kde.blender (Aleix Pol Gonzales, Plasma 5.18.0)
• Fixed a few visual glitches in the animations for the Widget Explorer (David Edmundson, Plasma 5.19.0)
• It’s once again possible to set your default email client to be a terminal program and have everything work properly when you click on mailto: links (Méven Car, Frameworks 5.67)

User Interface Improvements

• The System Tray’s settings window has received a major visual overhaul that makes it much more comprehensible and useful (Konrad Materka, Plasma 5.18.0):
  
• When you click on a notification, it now brings that app forward if the app doesn’t define a custom click behavior (Kai Uwe Broulik, Plasma 5.18.0)
• Throughout Plasma and System Settings, the “Get new [thing]” dialog has a fancy new look and is much more usable (Dan Leinir Turthra Jensen, Plasma 5.18.0):
  
• There are now keyboard shortcuts set by default for switching from one virtual desktop to another: Ctrl+Meta+Arrow keys (Björn Feber, Plasma 5.18.0)
• Scrollbars in the Breeze style for desktop apps are now wider and separated from the content view by a subtle separator line. You can see it in the other screenshots throughout this blog post! Basically after trying the fake overlay scrollbar style for a few years, we decided that it just didn’t work so we went back to the older style. Note that on mobile we now use real overlay style scrollbars with no content layout hacks, but instead of becoming invisible, the scrollbar becomes tiny and hugs the edge so you can still see your place in the scrollable view. (Marco Martin, Plasma 5.18.0)
• It’s now much simpler and more obvious how to create a WiFi hotspot (Jan Grulich, Plasma 5.18.0)
• Discover’s reviews sheet now has the proper width and is wide enough to display the reviews comfortably (Marco Martin, Plasma 5.18.0):
  
• A notification is now shown when Bluetooth device pairing is successful (Kai Uwe Broulik, Plasma 5.18.0):
  
• Bluetooth devices that communicate their battery level now show that level in the Bluetooth applet’s popup as well as in the Battery and Brightness applet popup (Kai Uwe Broulik, Plasma 5.18.0)
• The Plasma wallpaper slideshow feature now includes the default wallpaper path automatically so you don’t need to go hunting around and add it yourself (me: Nate Graham, Plasma 5.18.0)

How You Can Help

Please test the Plasma 5.18 beta release! You can find out how here. If you find bugs, file them–especially if they are regressions from Plasma 5.17. We want to get as much testing, bug filing, and bugfixing as possible during the one-month beta period so that the official release is as smooth as possible.

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.

Nextcloud announced their latest release and among the many new features is itinerary extraction from emails. That’s using KDE’s extraction engine, the same that powers similar features in KMail as well.

Nextcloud Hub

Yesterday Nextcloud turned 10 years, so that was a good date to announce a big new release, Nextcloud Hub (which I erroneously called Nextcloud 18 on Twitter). Nextcloud Hub now has email support built-in, and with it support for extracting booking information from train, bus or flight tickets as well as hotel and event reservations. Besides an easy to read summary of the booking data on top of the mail, there’s also the ability to add corresponding calendar entries.

Frank presenting itinerary extraction in Nextcloud Mail.

Those are very nice and useful features of course, but obviously I’m particularly happy about this using the same technology we implemented over the past two years for KMail and KDE Itinerary, thanks to a collaboration started at FOSDEM 2019.

Integration

How to get a C++ extraction library and a PHP web application together isn’t entirely straightforward though. We ended up doing this via a separate command line extractor tool, similar to how the Plasma Browser Integration interfaces with the extractor as well.

During the Nextcloud Hackweek last week we also extend the command line tool to produce iCal output, to avoid some code duplication for the calendar integration and ensure compatibility with the KDE Itinerary app. These changes didn’t make it into the current release packages, but should become available with the next update.

That leaves the question of deployment, for PHP applications that’s usually just unpacking an archive, but for native executables things are a bit more complicated. The installation packages therefore contain a full static build of the extractor. As a side-effect of this itinerary extraction is currently only supported on 64bit x86 platforms.

Nextcloud Mail showing a Deutsche Bahn train booking.

Using the same technology everywhere of course also means improvements benefit everyone. So I’m very much looking forward to the increased user base resulting in more data sample donations and contributions in general :)

FOSDEM 2020

If you are visiting FOSDEM in two weeks, there will be plenty of opportunity to learn more about all this, for example by visiting Jos’ Nextcloud talk, my KDE Itinerary talk, or by dropping by the KDE stand in building K and the Nextcloud stand in building H. See you in Brussels!

In a product like Plasma, knowing the kind of things our existing users care about and use sheds light on what needs polishing or improving. At the moment, the input we have is either the one from the loudest most involved people or outright bug reports, which lead to a confirmation bias.

What do our users like about Plasma? On which hardware do people use Plasma? Are we testing Plasma on the same kind of hardware Plasma is being used for?

Some time ago, Volker Krause started up the KUserFeedback framework with two main features. First, allowing to send information about application’s usage depending on certain users’ preferences and include mechanisms to ask users for feedback explicitly. This has been deployed into several products already, like GammaRay and Qt Creator, but we never adopted it in KDE software.

The first step has been to allow our users to tune how much information Plasma products should be telling KDE about the systems they run on.

This mechanism is only integrated into Plasma and Discover right now, but I’d like to extend this to others like System Settings and KWin in the future too.

Privacy

We very well understand how this is related to privacy. As you can see, we have been careful about only requesting information that is important for improving the software, and we are doing so while making sure this information is as unidentifiable and anonymous as possible.

In the end, I’d say we all want to see Free Software which is respectful of its users and that responds to people rather than the few of us working from a dark (or bright!) office.

In case you have any doubts, you can see KDE’s Applications Privacy Policy and specifically the Telemetry Policy.

Plasma 5.18

This will be coming in really soon in the next Plasma release early next February 2020. This is all opt-in, you will have to enable it. And please do so, let it be another way how you get to contribute to Free Software.

If you can’t find the module, please tell your distribution. The feature is very new and if the KUserFeedback framework isn’t present it won’t be built.

Are you using Kubuntu 19.10 Eoan Ermine, our current Stable release? Or are you already running our development builds of the upcoming 20.04 LTS Focal Fossa?

We currently have Plasma 5.17.90 (Plasma 5.18 Beta)  available in our Beta PPA for Kubuntu 19.10.

The 5.18 beta is also available in the main Ubuntu archive for the 20.04 development release, and can be found on our daily ISO images.

This is a Beta Plasma release, so testers should be aware that bugs and issues may exist.

If you are prepared to test, then…..

For 19.10 add the PPA and then upgrade

sudo add-apt-repository ppa:kubuntu-ppa/beta && sudo apt update && sudo apt full-upgrade -y

Then reboot. If you cannot reboot from the application launcher,

systemctl reboot

from the terminal.

In case of issues, testers should be prepare to use ppa-purge to remove the PPA and revert/downgrade packages.

Kubuntu is part of the KDE community, so this testing will benefit both Kubuntu as well as upstream KDE Plasma software, which is used by many other distributions too.

• If you believe you might have found a packaging bug, you can use a launchpad.net to post testing feedback to the Kubuntu team as a bug, or give feedback on IRC [1], Telegram [2] or mailing lists [3].
• If you believe you have found a bug in the underlying software, then bugs.kde.org is the best place to file your bug report.

Please review the release announcement and changelog.

[Test Case]

* General tests:
– Does plasma desktop start as normal with no apparent regressions over 5.16 or 5.17?
– General workflow – testers should carry out their normal tasks, using the plasma features they normally do, and test common subsystems such as audio, settings changes, compositing, desktop affects, suspend etc.

* Specific tests:
– Check the changelog:
– Identify items with front/user facing changes capable of specific testing. e.g. “clock combobox instead of tri-state checkbox for 12/24 hour display.”
– Test the ‘fixed’ functionality or ‘new’ feature.

Testing involves some technical set up to do, so while you do not need to be a highly advanced K/Ubuntu user, some proficiently in apt-based package management is advisable.

Testing is very important to the quality of the software Ubuntu and Kubuntu developers package and release.

We need your help to get this important beta release in shape for Kubuntu and the KDE community as a whole.

Thanks!

Please stop by the Kubuntu-devel IRC channel or Telegram group if you need clarification of any of the steps to follow.

[1] – irc://irc.freenode.net/kubuntu-devel
[2] – https://t.me/kubuntu_support
[3] – https://lists.ubuntu.com/mailman/listinfo/kubuntu-devel

This week we added KPatience to flathub.

That makes for a quite a few applications from KDE already in flathub



Which one do you think we should add next?

View the Website under work here.

Week 1 Overview

• KDE Connect Promo Video made
• Implementing Liquid and Jekyll for Easy future expansion of the site
• Implementing Webp file format with fallback for unsupported browsers
• Implemented fetching Developer Blog Posts
• Worked with the Promo team to fix the wording on the website
• Worked with the KDE Developers to make the video and website better by taking feedback

It had been great fun working with KDE Community on my SoK 2020 Project that is making a Website to promote KDE Connect. I started early off making the website from December by having a lot of discussion with my mentors Carl Schwan and Piyush Aggarwal, and the KDE Connect Developers. They were all very supportive and provided very constructive feedback. So when the project got accepted last week a lot of the work was already over. My proposal included the more work that is required on the website and taking the website to as much perfection as possible.

The Website can be viewed here.

You can check out my proposal here. The repository that has the KDE Jekyll themed site is here.

This week I decided to make a video to put on the homepage to show off KDE Connect in real as the site only had illustrations and no real image of KDE Connect after a lot discussion with my mentors and Connect Developers.The final video is shown below.

When I started off I had no idea on how to make a promo video. At one point I thought I won’t be able to do it as I had never edited a video in my life except for some family videos on my phone using some simple apps. But I took the challenge and Carl helped me by recommending KDE’s Own Video Editor Kdenlive. With the resources I had own the wiki and youtube, it was easy to pick up Kdenlive. I started by making the Screen recordings I required. Then I edited the video out in Kdenlive. Kdenlive surprised me with its powers. I would like to take this oppurtunity to thank the Kdenlive Developers for such an awesome video editor. (After I am done finishing with this website I want to start contributing to KDE Connect and Kdenlive!). Before using Kdenlive I actually used a paid software to make a mock video and after Carl’s recommendation switched to Kdenlive and I am in love with it. It is much better and powerful than the paid software. The Dropbox Containing the Kdenlive files and assets is here.

I made many versions of the video and each time I posted them on the Connect Developer group. Since the Connect Developer Group is very active, most of the developers provided valuable feedback and recommendations and I continued to work on the video during the week to make it as perfect as possible and reach the expectations of the community. The feedback from the community made me excited and I worked with that motivation. I also contacted the Promo team and took their advice. They were very supportive and they also helped with the text on the website. The week went by fast while I was constantly making changes to the video as feedback came. It was a lot of fun and such constructive critisism motivates you. I also went on to implement Webp image support for faster webpage loading, Jekyll to support easy expansion and fetching Developer Blog Posts from RSS feeds on to the site using Jekyll-Planet Plugin. Currently the website looks like shown below.

It was a great learning experience this week and I learnt a lot of new things from the community. Waiting for an awesome next week too.Don’t forget to checkout the website. So with that I conclude this post. See you in the next one. And as my mentor says : “Happy KDEing!!”

Following Kévin here’s the summary of what happened around KDE PIM in the last two months. While this post got slightly delayed due to the holidays, work didn’t slow down at all. More than 1300 changes by 26 contributors landed in the KDE PIM repositories, and we got the 19.12.0 release out in December.

KMail

• Work on DKIM validation of emails continued, in particular regarding improving the parsing of authentication results.
• KMail’s snippet system can now also insert attachments, with the attachment names being able to use the variables of the snippet system as well.

Customizable attachment names in KMail's snippet system.

• The extraction engine behind the itinerary plug-in received a number of improvements described in a dedicated post.
• Using GSSAPI authentication on IMAP servers no longer results in password prompts (bug 383279).
• Fixed false positives in the message view external references warning (bug 415254).
• Sanity-check collection path before performing recursive deletion in maildir backend (bug 414178).
• Fixed automatic folder expiration not triggering correctly (bug 414839).
• Warn when email identity settings cannot be written (bug 414171).
• Fixed saving dialog not proposing a file name (bug 414825).

KOrganizer

• The reminder daemon now honours the global notification inhibition.
• Month view: Fix background color computation with dark themes (bug 413521).
• Month view: Fix chronological sorting in day block (bug 232162).
• Agenda view: Fix grid colors when not using system settings (bug 411608).
• Incidence editor: Broken layout does no longer resize attendee list (bug 414977).
• Fixed recurrence rule generation for timezones with newer libical versions.
• Handle incidences in different time zones in KCalendarCore::MemoryCalendar.
• Optimize date-bayed caches in KCalendarCore::MemoryCalendar.

Kleopatra

• Redesigned certify dialog.
• Added remark support in key views and certify dialog.
• Fix overwriting files when exporting secret keys.

Akregator

• Support displaying icons from Atom feeds (bug 414086).

Akregator showing icons for all feeds again.

• Fix initial scroll position in inline article view (bug 177511).
• Allow to show feed copyright information.
• Fix getting the feed URL from a Youtube channel (bug 383381).
• Make the “Add feed” option more accessible (bug 297098).

Common Infrastructure

Following the KF6 sprint in November, preparations for the migration to Qt6/KF6 also started in KDE PIM, mostly in the form of porting away from already or about to be deprecated functionality in Qt5 or KF5, such as:

• KTcpSocket (replaced by QSslSocket)
• QRegExp (replaced by QRegularExpression)
• Pixmap-based icon functions (also improves scalability on high DPI displays), as well as moving to QStyle for determining icon sizes.
• qrand() (replaced by QRandomGenerator)
• D-Bus service monitoring in QDBusConnectionInterface (replaced by QDBusServiceWatcher)
• KRecursiveFilterProxyModel (replaced by QSortFilterProxyModel)
• and many more

Being able to do this in small steps and ahead of the full transition to Qt6/KF6 will make this transition much smoother than it has been in the past.

Help to make Kontact even better!

Take a look at some of the junior jobs that we have! They are simple, mostly programming tasks that don’t require any deep knowledge or understanding of Kontact, so anyone can work on them. Feel free to pick any task from the list and reach out to us! We’ll be happy to guide you and answer all your questions. Read more here…

KUserFeedback is a framework for collecting user feedback for applications via telemetry and surveys.

The library comes with an accompanying control and result UI tool.

https://download.kde.org/unstable/kuserfeedback/

Signed by Jonathan Riddell <jr@jriddell.org> 2D1D5B0588357787DE9EE225EC94D18F7F05997E

KUserFeedback as it will be used in Plasma 5.18 LTS

I bought a MacBook end of 2014. My initial reason to buy it was to improve the Kate port for macOS. Beside that, I wanted to try if the Apple ecosystem and macOS are really that great and will solve all my issues in life (short answer: no, they aren’t, at least not for me). The HiDPI screen looked nice, too :=)

After some initial “not a lot works”, if you don’t go the Homebrew or MacPorts way, the Kate port improved over the following years.

I learned a lot about standalone non-Linux deployment of applications and macOS specifics in the process.

As a side-effect of my porting efforts, with the help of others, I was able to improve the deployment of KDE Frameworks in some ways, e.g. by allowing to bundle more stuff inside Qt resources.

For example the KSyntaxHighlighting or KTextEditor frameworks are now just a library you link, you don’t need to deploy any extra data files. This is a huge improvement, if you want to bundle them with your standalone application.

Unfortunately, my initial hope, that we would get more people contributing to the macOS port (and with this to KTextEditor/Kate/…) didn’t really take off.

Beside some minimal help, not a lot happened.

I think my last self-provided bundle update for macOS was in 2016.

The binary factory still churns out new builds, you can grab them via the links on our download page.

I occasionally tried them, but they never got polished in a way like our Windows variants that we now even ship via the Windows Store.

Apple doesn’t make the world a better place with each update of macOS, see for example the now necessary notarized builds and the effort the cause for e.g. Krita (and with necessary I mean: you shall do it, otherwise your users are nagged with “do you really want to execute this…” stuff that makes a very bad impression).

In the last years, I used my MacBook more or less just to either grab some stuff from iTunes or do stuff inside my Linux VirtualBox there.

Given I anyways have a proper Windows 10 VM to take care of the Windows development for Kate (yes, Apple, Microsoft allows that officially, you can just buy a license, you can even get some ‘free’ developer VM images for a fixed time…), I just migrated my seldom used iTunes account to that machine.

With that away, I just installed purely Manjaro Linux on my MacBook last evening, who cares, I anyways don’t use macOS at all beside as VirtualBox startup environment.

I searched for some pointers in the internet, in the past I already had some parallel install. If you search a bit, you will find various hints how to do it.

If people want to do the same as me, a pure Manjaro install without keeping any macOS around, here a minimal how-to for a MacBook Pro Retina 13” (model number MGX82**/A, model id MacBookPro11,1):

• Get the USB installer from their Manjaro Linux homepage, I used the KDE variant ;=)

• Get it on a stick and plug it into your MacBook

• Boot up your MacBook (pressing the ALT key)

• Select the EFI boot option.

• Start the live system, like on any other machine

• If you want to have internet, which is a good idea to e.g. later easily install the Broadcom driver, use your mobile phone with USB-tethering

• Install it normally, I used the “erase my full drive and encrypt it” variant. Be careful, your data is gone afterwards, you got warned!

• Reboot your MacBook, you will boot into your fresh installed Manjaro

• Install the matching Broadcom driver for your kernel, something like “linux54-broadcom-wl”

• Install some fan control like “mbpfan-git” and enable it afterwards with “sudo systemctl enable mbpfan” + “sudo systemctl start mbpfan”

For me this did the job and the stuff is running well enough. The webcam won’t work without additional effort, not that I use it. No idea if Bluetooth or other stuff like the Thunderbolt ports work, but I never used that even on macOS.

Fortunately the HiDPI support on Linux & Qt & KDE has gone a long way since my initial try 2015 and now, with some scaling of 1.5 or 2, it is all nicely usable ;=)

Given I still have some macOS machines available at work, I might still try out some Kate bundles there from time to time, but my personal life is now macOS free.

https://zanshin.kde.org/2020/01/14/zanshin-0.5.71/

We are happy and proud to announce the immediate availability of Zanshin 0.5.71.

This updates the code to work with current libraries and apps from Kontact.

The GPG signing key for the tar is
Jonathan Riddell with 0xEC94D18F7F05997E
download.kde.org

 

We are happy and proud to announce the immediate availability of Zanshin 0.5.71.

This updates the code to work with current libraries and apps from Kontact.

The GPG signing key for the tar is Jonathan Riddell with 0xEC94D18F7F05997E.

2019

Let’s have some statistics first! Statistics are fun! (And notoriously unreliable) We started 2019 with about 450 open bugs — and that’s how we ended 2019. That said, we had 1236 new bug reports and closed 1272. Still, our 2018 fund raiser was all about getting rid of bugs, and that seems to be a tough proposition.

According to openhub, we had 2271 commits from 60 contributors. This excludes translation commits, because those are still done in a subversion repository, apart from Krita. We had nine releases (4.2.0 to 4.2.8) in 2019, slightly less than we’d planned, we’d wanted to have twelve releases. We had four Google Summer of Code students, and most of their work has already been merged and will be in Krita 4.3.0: a new magnetic selection tool, the history docker and the android port.

Next to fixing bugs, we’re work on that 4.3.0 release, but the main reason why 4.3.0 didn’t happen in 2019 was because rewriting the core system for loading brushes, gradients and so turns out to be much more work than we had ever thought. We should have approached that much more gradually, but we couldn’t figure out how to make that work.

We had 2,346,618 unique downloads from the download page on this website; that excludes downloads from other download sites, downloads from release announcements or downloads from the various stores. At a guess, we’ll have topped 3,000,000 downloads in total this year.

We kicked off krita-artists.org as our new discussion and support site, and we’ve already got more than 1000 active users.

We also had the largest Krita Sprint ever.

Through the donation button on krita.org and the donation page you see after a download, we got €29,715.20 in donations. We made enough money apart from the donations from the Windows Store and Steam that this year we could hire three new full-time developers. And we got a grant from Epic, too.

In short, 2019 was a year when Krita saw a huge growth, almost scarily so!

If you want to play with what will become Krita 4.3.0, check out the nightly builds! (Windows, Linux, macOS)

2020

Our plans for 2020 are first and foremost to release Krita 4.3.0, with new features, lots of bug fixes, lots of performance improvements and the new resource management system. That’s going to take time, unfortunately. It’s that we’re releasing bug-fix releases that sometimes have smaller fun features all the time, otherwise it would feel like we’re doing something we shouldn’t be doing. That is, doing too big a rewrite. We are making progress, though and we’re going to have a small hacking sprint in February focused on the resources rewrite.

We’ll have our yearly large contributor sprint directly after the Libre Graphics Meeting in Rennes, France, hosted by ActivDesign. It’s the first time in many years that we’ll have a contributor get-together that’s not in Deventer!

We’ve also got lots of ideas for improving our way of working, for performance improvements to the brush engines, new features for the brush engines, workflow improvements (like a search function for the UI).

Task 1

View Task 1

Proxy types can be tricky. If we got a QChar (or a reference to a QChar) by accessing a character in a QString with the operator[] as most people would expect to, the automatic type deduction requested by auto current = hello[i] would deduce that current is of type QChar.

But QString::operator[] does not return a QChar. It returns a QCharRef. Even if we think of it as a reference to a QChar, the compiler does not, and the automatic type deduction can not remove the reference part like it would if the return type was a proper reference (QChar&).

This means that current will be a value of type QCharRef. When we modify it, it will modify the original string (contrary to what most people expect because of C++’s value semantics).

One of the solutions here is not to use automatic type deduction and explicitly specify the type of current to be QChar.

QChar current = hello[i];

Another thing that could help is to declare the hello string to be const. It is a good practise to use const by default when declaring variables.

The second issue in the first task was that the original string ends with an exclamation mark, while the string in the Q_ASSERT does not.

Task 2

View Task 2

The problem in the second task is similar to the previous one. When we see strings being concatenated, we assume that the result is also a string.

String concatenation is slow (you can check out this post for more info) and Qt allows us to activate delayed (lazy) concatenation by defining QT_USE_QSTRINGBUILDER. Instead of operator+ returning a string, it will return a class called QStringBuilder which will keep references to all strings we want to concatenate and perform the concatenation only when we convert it to a QString.

This means that when we use the automatic type deduction – auto message = ... – we get a message variable that is not a string, but rather an object that keeps references to all the strings we want to concatenate. When we try to print it out with qDebug, it will concatenate all the strings and print out the result.

The problem is that one of the references in our example will be a dangling reference – reference to a temporary string returned by the tr function that has been destroyed before the actual concatenation is performed. So, we get undefined behavior (most likely a crash in this case).

This is easily fixed by explicitly specifying the type of message to be a QString. This will perform the concatenation before the temporary string returned by the tr function is destroyed.

Task 3

View Task 3

The final task is quite different to the previous ones. It shows a function implemented with two for loops nested into each other. The time complexity of the function is O(m*n) where m is the length of xs and n is the length of ys. The memory complexity is O(1).

If we analyze the function, we can deduce that it counts all the items in xs that are smaller than or equal to the smallest value in ys. While the provided example uses sorted vectors, it is obvious that this function also works for unsorted vectors.

One approach (a frequently submitted one) to solving this using the algorithms found in the standard library is to sort both collections and then use the lower_bound to find the first element in (now sorted) xs that is not smaller than the smallest element in ys (ys[0] after sorting). We can then use std::distance to get the count how many elements we have between xs.cbegin() and the item we just found.

The time complexity of this solution is O(n log n + m log m) which is better than the original implementation, but the memory complexity grew to O(m + n) because we need to copy the original vectors in order to sort them, which is significantly worse.

If we go a bit deeper, we can see that we are using just ys[0] so we don’t really need to have the whole vector sorted. We just need the smallest value in ys. We can find this in linear time with the std::min_element algorithm.

With this, we would end up with O(m log m + n) time complexity and O(m) memory complexity, as we are still sorting the xs. Better, but not good enough.

Now the question is whether we really need to sort the xs?

If we know the minimum of ys we need to compare xs against, it is much cheaper just to go through all the unsorted xs one by one and check which ones are smaller than to sort the xs first. This can easily be done with std::count_if:

int counting(const std::vector<int>& xs, const std::vector<int>& ys) { if (ys.empty()) return xs.size(); const int min_y = *std::min_element(ys.begin(), ys.end()); return std::count_if(xs.begin(), xs.end(), [=] (int x) { return x <= min_y; }); }

The time complexity of this solution is O(m + n) and the memory complexity is O(1) which is the best we can do for this problem.

The post KDAB Challenge Solutions appeared first on KDAB.

Late 2019 year-end post, I know. It’s been a rather busy start to the new year even when I tried to hit the ground running. Unfortunately, some things like blog posts have taken a backseat. Hopefully not for long.

2019 was a wild year for me personally and I don’t mean that in the completely good sense. One of the highlights, though, was being hired to do contractual work for KDE as a technical writer and documentation specialist. TL;DR I went through KDE’s developer docs and queried a few devs on the state of the documentation and what needs to be done to make it easier for new developers to get started using our libraries/frameworks and contribute to KDE projects.

It was definitely an honor to formally work for the community. I have been a sporadic contributor (lately more just helping out on IRC) and getting the chance to work on more technical matters again and be involved on a deeper level was exciting. Plus, the accountability definitely helped in the motivation aspect. Sadly, due to personal circumstances, I wasn’t able to follow up on the matter after the contract formally ended. Fortunately, that period is over and I can get the ball rolling again.

It’s probably no secret to both seasoned developers and those just getting their feet wet that our developer documentation is largely outdated except for a few bright points in the Community Wiki (kudos to contributors who continually update that!). Some hail from the pre-Frameworks days and some have never even seen the light of KDE4 (remember, there is no such thing as “KDE5”). They’re also a bit scattered here and there, with incomplete or even missing information. Suffice it to say, there’s plenty of things to do and plenty of ways for KDE helpers to join the game.

Here are just some of the things that need to get addressed in the coming months:

• API documentation, a.k.a. apidocs, need filling up with more information and especially examples.
• New or updated documentation for “hot” areas like Kirigami and Plasma/Mobile need to be written.
• The TechBase and Community Wikis need to be cleaned up and content migrated to their proper places
• Tutorials need to be updated or written and placed in their proper location (wiki or apidocs)
• An improved onboarding for new contributors as well as external developers need to be developed.

You can view the initial report I submitted in June as well as an update I wrote in December here.

KDE Developer Documentation Report (June)Download KDE Developer Documentation Update (December)Download

2019 was spent for analysis and planning so, hopefully, 2020 will be spent putting all of these into action. Writing documentation is often seen as a boring task but, especially when it comes to developer documentation, it can be the perfect opportunity to become familiar with the software and libraries, the tools and processes, and, most importantly, with the people and the community that make KDE awesome

I’ve been involved in the gbgcpp group, a part of the larger Sweden C++ community, for a couple of years. It is fun to see that there is a lot of C++ developers out there, once you start looking for them.

In the next meetup, this Wednesday, there will be both C++ and Qt. The topic is to implement Ribbons in Qt, based on a seminar by Dag Brück. If you happen to be in the vicinity of Gothenburg, I recommend you to go there!

I’d also like reach out and thank Sylog for hosting the event!

Could you tell us something about yourself?

My real world name is Andy Statia, but I go by Never Dot in the digital space. I live and grew up in Canada, for which I’m very grateful. Being in a temperate zone country, I get to experience the wild fluctuations between the seasons, which I’ve always found has really stimulated my imagination. Being able to directly experience frozen wastelands, verdant forests, and dying cities all without going anywhere has given me lots of ideas for my worlds.

I’ve always had a keen interest in both computers, drawing, and design. This meant spending my nights after school doodling and designing entire worlds then later learning to program on the family computer so I could bring those worlds to life through video games. This continued on
throughout my school years and I explored my artistic side through the creation of game art and world design. I later went to the University of Waterloo and graduated with a bachelor’s of mathematics. Since then, I’ve been working in the computing field, but always working to build up my creative side through digital art and web design.

Do you paint professionally, as a hobby artist, or both?

For most of my life it was just a hobby, but in February 2016, I decided to try to turn professional and dedicated myself to starting a new company called Never Dot, which would be where my professional work would be created. Since then, I’ve strived to improve my art and learn professional skills.

What genre(s) do you work in?

I could easily be accused of having attention deficit disorder, because I have a hard time sticking to one genre. My current work is evidence of that, as I’ve tried to combine fantasy, science fiction, modern day life, and pretty much any other genre that I can rationalise into my world. Sticking to a single genre has always seemed unnecessarily restrictive and mashing together very different genres has always been a point of interest for me, to discover how they react to each other and work together (or not). My primary preference is creature design.

In my children’s books and comics, you can find spaceship flying dinosaurs with ray guns right alongside common vegetable folk running their shops and buying groceries (which is hopefully not just themselves). A turtle family deals with mobile phones and family issues while my main character, an octopus, has fiddled with magic to fix his computer as dragons try to steal his Halloween candy. I’m going to work pirates into this world next, most likely.

Whose work inspires you most — who are your role models as an artist?

When I was just starting out professionally, I was sorely lacking in connection to the artistic community, which I still feel to be the case. But in the few years hence, I’ve discovered Li Chen of Exocomics who I consider to be my gold standard for what I’m trying to achieve. The quality of her artwork and the level of cuteness she brings forth in everything she does is exactly what I want to achieve in my work. If I’m ever able to match her art, I would consider my artistic life’s goal to have been met.

However, on the opposite end of the spectrum is Ross Tran, Asia Ladowska, and Laura Brouwers (Cyarine). These people have shown me it’s possible to create incredible work through practice, time, and experience. Drawing humans is my greatest fear, but I need that skill set to be able to tell the visual stories I want to tell, so these are my role models for that pursuit.

Lastly, I should note Randall Munroe of XKCD, who shows all of us that you don’t need to be a great artist to be interesting and worth paying attention to.

How and when did you get to try digital painting for the first time?

While I had been “digitally painting” in MS Paint from a very young age, I suspect my pixel art of the time isn’t what you’re interested in. For a more professional level of digital painting, I would say it was during my first co-op work term at university. It was my first period of time earning meaningful income and the first thing I set out to purchase was a drawing tablet. Since I’m quite bad with money, I opted for the largest tablet I could find, which was the Wacom ArtZ II 12×12 tablet. It was big, square, and threw off the aspect ratio on my drawing for a couple years before I clued in that I should be limiting the drawing area to correct for that. I later migrated to the Intuos line of tablets and used some Bamboo tablets at work (as I’d long since gotten used to a stylus). I am now on my second Cintiq for day-to-day work.

What makes you choose digital over traditional painting?

The inability to undo is probably the biggest reason to go with digital over traditional. I only traditionally painted in a university course and since I was already digitally painting at the time, I found that the inability to control layers, adjust effects, and such in physical media was frustrating.

I’ve never lived the traditional painting life, so digital has always been my first choice. However, I recognise that experiencing traditional painting methods has benefits that would help inform my digital painting techniques.

How did you find out about Krita?

I had been using Fractal Design’s Painter (now Corel’s) for many years, over a decade, and while I depended on it immensely, it was also somewhat buggy and the numerous upgrades I’d purchased were always introducing more problems than solutions for me. As such, I was pushed to find an alternative. I looked into Sai and Clip Studio Paint as being well received in the community. I was avoiding Photoshop both due to the subscription requirement and the fact it wasn’t directly targeted at natural media painting. Krita came up in my research as being a free painting tool. I checked out numerous YouTube reviews and comparisons, and being free let me try it out directly.

What was your first impression?

My first experiences with the program were that it was very smooth and easy to figure out. Coming from a Painter background, I was looking to recreate my workspace in Krita and ensure it had the same capabilities. Exploring Krita’s brushes was probably what got me hooked, as I’d found a large sponge brush that gave the effect of fog or mist. This was something I’d never effectively created in Painter and I was immediately entranced by the simple effect it produced. After I got the keyboard shortcuts figured out (or reconfigured) and tools identified, I was settled and able to get work created in Krita. Initially, I used it for effects, creating the main work in Painter. But in time I was creating entire pieces in Krita.

What do you love about Krita?

The large sponge brush, which I believe comes from David Revoy’s brush pack, was the first thing that really captured my interest. Such a brush can of course be created in other programs, but brushes are the heart and soul of these programs, so that got me hooked.

I found the reference docker to be extremely useful. Having a little docked panel on the side that automatically colour picked when I clicked on it, allowed independent panning and zooming, was probably the most useful tool I’d used in quite a long time. Since I had a lot of different characters to paint that needed consistent colouring, I would just load an unshaded picture of them to use as a palette, since I could then know which red was the body red vs. the sock red. Normal colour palettes aren’t as quick to find desired colours. Sadly, this tool was removed some versions ago and replaced with something a bit less useful.

A tool that sort of existed in Painter, using vector shapes as guides, has proven much better in Krita. The guides tool, which allows for parallel lines, ellipses, perspective drawing, etc. is extremely intuitive and useful. Particularly the vanishing point guide. Other programs attempt to display a 3D grid and provide complex controls to position it. Krita just gives you the vanishing point and two control points for each edge, which is easy to align to your sketch. For ellipses, the ghosted circles showing before I start drawing is fantastic. I’ve sometimes used this preview with the drawing constraints turned off just to help line things up.

What do you think needs improvement in Krita? Is there anything that really annoys you?

A generally known gap in Krita’s toolkit is text support. I discovered right away it wasn’t even basically functional, so I use Illustrator to do all my text layout for Krita. Having easy to use text boxes would be great.

Working with vectors is somewhat more cumbersome in Krita than other applications. In most other applications, each shape is its own layer, which makes it easy to locate them, manipulate them, and create them, as it doesn’t require creating a special layer to manage them.

A persistent bug that impacts all my work is the “unable to pan after using something in the interface”. This typically happens after renaming a layer and then trying to pan immediately after with the spacebar. Instead of panning, nothing happens, and I wind up drawing a harsh line through my artwork, which I hopefully notice and undo immediately. This interrupts my workflow several times per drawing session.

As noted earlier, I haven’t found the new reference image tool to be particularly usable. A reference image should be visible and stationary while drawing. I’m often panning and zooming while working, but if the reference image gets panned or zoomed off screen, it becomes useless. I also frequently need to just have a zoomed in portion of the reference image up, so I can refine details of it, which the old docker did perfectly, since it allows for sizing that window area and zooming within it independently.

More natural media brushes is always welcome, particularly from the base install. This is one area where I sometimes look back at Painter for, as it had such a wealth of natural media brushes. Recreating them myself isn’t always possible (i.e. doesn’t produce good results).

What sets Krita apart from the other tools that you use?

Being free is an extremely impressive feature for this product. While that doesn’t relate to features, the fact that a tool of this level of capability is free is amazing. It has successfully replaced a $500 professional tool without sacrificing much of anything.

Something Krita excels at for me is being able to handle very large canvases without crashing or slowing down. This was a point of concern for me with Painter and I was amazed that Krita was able to continue running at full speed at progressively larger canvas sizes. While I do still learn about its limits, I’m able to push it farther than what I used to have.

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

I’ve done a lot of different pieces over the last three years for Never Dot, many I’m very proud of, many that I cringe at. But one of the more exciting pieces I did recently was for last Halloween, which features a lot of my characters packed into a tight scene. Highly detailed scenes have always interested me, because you can see something new time and time again when you come back to it. Playing with lighting effects is also something I quite enjoy and this one takes advantage of it a lot. I previously noted that I have a hard time sticking to one genre and if anything highlights that, it’s this scene with sci-fi, fantasy, modern day, dragons, and steampunk marching around.

What techniques and brushes did you use in it?

My work is mostly cartoon art and painted backgrounds. I created my own pen brush, as none of the ones in Krita were quite the same as what I was used to. It’s a simple solid brush with hard edges.

I use the hard light layer mode for shading, using the inherit alpha feature to limit the shadows to the foreground character. This feature has saved me immense amounts of time.

Another extremely useful capability is filling line art into a different paint layer. This saves hours of my time.

Where can people see more of your work?

I put almost all of my work up on my website and various social media accounts. You can find my comics, drawing practice, and links to my children’s books on my website at: https://neverdot.com

You can also look me up on Instagram (@neverdotworld), Twitter (@neverdot), and Reddit (/u/NeverDot). I’ve also got a YouTube channel where you can see the real me! Find that at https://youtube.com/neverdot.

I’ve self-published four children’s books featuring my world which are fully illustrated with my work. The first book used Painter and the next three were completely done in Krita! You can get those on Amazon, Indigo, and other book websites. Check out my website details on the books!

Anything else you’d like to share?

Krita being open-source is a huge victory for both the open-source movement and digital artists. Anyone with a computer now has access to a fully capable drawing solution that compromises on nothing (well, maybe text support). If my professional Never Dot work becomes highly successful, I’ll definitely be looking to financially support the Krita development team to ensure future generations of artists are able to benefit from such a polished art tool. Thank you Krita team! Your dedication to the project shows and everyone using Krita is thankful for having you working behind the scenes.

In august, Dan Vrátil wrote about Kontacy and Google integration issues. Kontact is KDE’s personal-information management suite, which builds on top of Akonadi, and includes KMail, contacts and calendaring.

The most important bit of Dan’s blog post is this:

This is due to an oversight on our side which lead to Google blocking Kontact as it did not comply with Google’s policies.

You can see the consequences of that oversight in KDE bugs, for instance kmail no longer allows addition of gmail account or Dolphin Kio-gdrive authentication with Google account fails. There are probably multiple duplicates in KDE’s bugzilla as well.

The Google account used for the integration – the one that “owns” the API tokens and a few other things – has the KDE e.V. board email attached to it. That’s sensible, since Google integration in KDE applications and frameworks is something institutional, not personal (so it wouldn’t make sense to have any individual developer’s address on it). The e.V. exists to support the community, after all.

This does mean that when things break with the integration – and they have been broken, for months now – the board gets email with questions. This is a semi-official statement from the board about what’s going on (semi-, because it is on my personal blog, and statements like “I don’t know” and “I don’t use” are personal, not institutional).

• Why have things been broken for months? The integrations were shut down by Google for policy compliance reasons. Finding out what those policies are (board), fixing things to comply (KDE-PIM developers) and filing an appeal (board) all take time, lots of time, and then you get into the morass of waiting-for-appeal-to-go-through.

  I’ve clicked around in the application dashboard for our account, mostly going “what do they want us to do?” Frankly, I can’t tell. There’s an orange dot next to kde.org sometimes, which suggests the domain needs to be verified. I have no idea.

• Has there been any progress? Yes, there has. kaccounts-provider has been approved for calendar and contacts (and some others), so it should start to work again. I don’t know what functionality exactly is covered by this provider (but see below).
• Is there a workaround? You can use the one described in Dan’s blog post.

So, progress is really slow because we’re dealing with a totally opaque “adversary”. There is some progress, and we’re expecting that the KDE PIM developers will announce success soon-ish.

Update: Dan has been active behind the scenes, and calendar and contacts syncing should work again if your distribution backports some specific changes (the changes will be in the February release of KDE software). He writes

We’ve recently had to adjust which parts of Google accounts we request access to when users sign into their Google account in Online Accounts KCM. The list of requested scopes needs to be adjusted in kaccounts-providers package as well, otherwise login is refused by Google. This mostly affects KIO GDrive, which accesses user’s GDrive account through Online Accounts.

Note that GMail is not yet fixed; that’s a separate effort. Thank you Dan for clarifying!