January 22, 2020

Ayer se anunció la sede y desde este momento el blog se va a dedicar a promocionar al máximo el mimso. Y es que en abril se celebrará en Málaga la reunión anual en España de usuarios y desarrolladores de KDE, Akademy-es 2020. Concretamente se celebrará del 24 al 26 de abril y es el momento de seguir preparando el programa. Como el evento es una celebración comunitaria se abrió en el momento del anuncio de la sede la posibilidad de que todo el mundo, además de acudir,  participara de forma activa. Así que presenta tu charla para Akademy-es 2020 de Málaga que se celebra conjuntamente con Opensoutcode y muestra a toda el mundo tu proyecto personal o comunitario.

Presenta tu charla para Akademy-es 2020 de Málaga

En Akademy-es se realizan las típicas charlas que presentan las novedades tanto de las aplicaciones como de las herramientas de programación, siendo un gran escaparate para potenciar proyectos o mostrar al mundo el trabajo realizado por los diversos equipos.

Presenta tu charla para Akademy-es 2020 de Málaga

En anteriores ediciones en estas charlas (extraído del programa de Akademy-es 2018 de Valencia) descubrimos 5 maravilla de Plasma 5,  aprendimos más de Discover, conocimos la asociación KDE España, vimos a Mycroft en directo, vimos pinceladas de un posible futuro de KDE, aprendimos como colaborar con KDE sin ser programador, conocimos mejor la relación de Slimbook con KDE, aprendimos a hacer aplicaciones para el móvil y tuvimos un mesa debate de la gente de GNU/Linux Valencia, entre otras cosas.

Recordemos que este año Akademy-es 2020 se celebrará en Málaga del 24 al 26 de abril dentro del gran evento libre Opensouthcode

¿Y qué encontraremos en esta edición? Pues depende de ti, ya que si tienes algún tema que crees que interesará a la Comunidad KDE y sus simpatizantes, no lo dudes a y presenta tu charla para Akademy-es 2020. Estaremos encantados en escuchar tu propuesta.

Si quieres más información visita la web oficial de Akademy-es 2020, no obstante aquí te lo puedo contar yo:
Para proponer actividades se deberá enviar un correo a akademy-es-org@kde-espana.es antes del 29 de febrero con un resumen breve de la presentación.

Presenta tu charla para Akademy-es 2018Es importante tener en cuenta las siguientes consideraciones:

  • Se puede elegir entre dos formatos de charlas:
    • Charlas de 45 minutos.
    • Lightning talk de 10 minutos.
  • Si la duración de las charlas propuestas no se ajusta a ninguno de estos dos esquemas (por ejemplo, si se necesita más tiempo), esto debe indicarse claramente en la comunicación.
  • Se permitirá a KDE España la distribución bajo una licencia libre de todo el material utilizado para la realización de la actividad, así como de la grabación de la misma.
  • La charla puede ser tanto a nivel de usuario como de nivel técnico.

Se trata de una gran oportunidad de darte a conocer en el mundo KDE y en el mundo del Software Libre en general.

Más información: Akademy-es 2020

¿Qué es Akademy-es?

Akademy-es (#akademyes, que es la etiqueta para las redes sociales) es evento más importante para los desarrolladores y simpatizantes de KDE, que se ha ido celebrando desde el 2006 con éxito creciente.

En general, las Akademy-es son el lugar adecuado para conocer a los desarrolladores, diseñadores, traductores, usuarios y empresas  que mueven este gran proyecto.

En ellas se realizan ponencias, se presentan programas, se hace un poco de caja para los proyectos libres (camisetas, chapas, etc) pero sobre todo se conoce a gente muy interesante y se cargan baterías para el futuro.

Podéis repasar las anteriores ediciones en estas entradas del blog:


January 21, 2020

Plasma 5.18 LTS Beta has been released, which brings many exciting new features to a computer near you, especially if you’re upgrading from our previous LTS release, Plasma 5.12. Of course for us developers this now means that a stable git branch has been created and we can work on new stuff on master to eventually become Plasma 5.19, scheduled for an early June 2020 release. This blog post is less about KDE code, though.

Plasma notification popup with a chat message and a text field to send a reply from inside the popupNo need to rub your eyes: Quick reply with Telegram on Plasma 5.18!

One of the things I enjoy most about working in open source is venturing out into other projects, doing things that are unfamiliar, and the challenge of finding my way around foreign code bases. You know, sometimes you’ve just gotta do things yourself, no matter what part of the stack they’re in, if you want your overall vision to become a reality.

With Plasma 5.18 I finally implemented quick reply in notifications. Something I’ve been wanting to have for many years. But what’s a feature without an application using it? Since Telegram appears to be quite popular in our community and its Linux desktop client hosted on GitHub, I decided to give it a go.

Telegram’s notification implementation had recently been ported from libnotify to use plain DBus calls instead, which made adding support for quick reply really straightforward. I browsed their git repository and found the necessary infrastructure for handling notification replies was already in place for their other supported platforms. The patch itself took me basically a minute to write (which means there’s no excuse for you not adding this feature to your messenger!) and my pull request was merged after only minor tweaks.

Once released, I’m sure you’ll enjoy this added productivity when having to deal with lots of chat rooms and conversations! Many thanks ilya-fedin for helping me build and test my patch, which unfortunately turned out a lot more difficult than I had hoped.

OBS Do not disturb

Plasma features a “do not disturb” mode where notifications are suppressed so you can focus on your current task or keep others from seeing private messages. The upcoming Plasma 5.18 release also gained a configurable global shortcut for quickly enabling this mode any time. An idea I had a few weeks ago was to write a plug-in for Open Broadcaster Software Studio to automatically inhibit notifications while streaming or recording – so I did just that.

Plasma notification center stating "Do not disturb while OBS is active (recording in progress)"Quiet please, recording in progress!

It uses the OBS Studio Frontend API for detecting streaming/recording start and stop events and then places a notification inhibition via DBus. This was a good exercise in build systems for me as I wrote the, admittedly tiny, CMakeLists.txt from scratch without any of the ECM convenience you normally get when working on a KDE project. Moreover, to keep dependencies super minimal by using libdbus as opposed to Qt’s powerful DBus wrapper was quite interesting. I tried to save myself from any tedious C memory management by wrapping the objects in smart pointers with custom deleters, of course.

Some more notification things

Now that quick reply API found its first user, I made some minor tweaks to how it behaved: if the only visible action in the notification would by a lonely “Reply” button, the text field is shown right away instead. This also provides a visual cue that a reply is possible from within the popup.

An application can already provide a “default” action which is invoked when the notification bubble itself is clicked. For applications that don’t, for instance Thunderbird, there is now a fallback mechanism in place which, when clicked, at least brings the application window to the front and dismisses the notification. There’s also a new “Other Applications” category in settings so you can again have shell scripts spawn notifications that remain in history.

On my computer I have applications I daily need for work, such as web browser, web radio, IRC client, IDE, etc in my autostart. With all the startup performance work we did in the past months, my session starts so fast that Chrome is launched before Plasma’s notification service is fully up and running. This causes Chrome to fall back to its custom notification implementation until restarted. To fix this I submitted a patch to have it also check for DBus-activatable services before assuming there’s no notification service available.

I did some icons!

Finally, over the holidays I toyed around with the Inkscape vector graphics editor to create some Breeze icons I was sorely missing. I’m a huge fan of KDE Itinerary, our digital travel assistant. One of the many things it supports for managing boarding passes, train tickets, and exhibition passes is Apple’s .pkpass file format. While you typically get them in your Email client and import them directly, I still felt a proper file icon was missing.

Four file icons, different colored paper sheets with an icon in the middle: Apple Wallet (skyblue with a stylized wallet), Audacity (dark blue with audacity logo (headphones with lightning between them)), Windows link (LNK) file (dark gray with stylized chainlink), XHTML (purple with a globe)Four new Breeze mime type icons

Another set of files I regularly encountered without an icon were Audacity projects. Thanks to Carson Black / jan Pontaoski for finalizing a draft icon I created for that purpose. I also noticed that XHTML files looked more like XML than HTML. While generally icons that differ only in color are bad for accessibility, in this case I changed it to a purple HTML icon to keep the XML connection (Breeze XML icon is purple) but put the main emphasis on the globe, i.e. it’s basically still a website. I also changed the file icon for Windows .lnk files to follow Breeze’s general paradigm for links.

To conclude, why not start the new year doing something you’ve never done before? Go start something from scratch, go make some artwork, go fix a bug in an application you use all the time but never contributed to! :-)


 ¡Ya tenemos sede! Hoy ha sido anunciada la gran noticia de la semana para los simpatizantes y miembros de la Comunidad KDE: Akademy-es 2020 se celebrará en Málaga del 24 al 26 de abril Un evento que al que no puedes dejar de acudir  si te gusta el Software Libre, y más si eres usuarios o colaborador del proyecto KDE.

Akademy-es 2020 se celebrará en Málaga

Como me gusta recordar cada cierto tiempo,el momento clave de mi vida que hizo que en estos momentos sea un miembro orgulloso de la Comunidad KDE fue mi primera Akademy-es, la del 2010 de Bilbao.

A lo largo de este evento me encontré con grandes personas y actuales amigos, descubrí lo enorme y fabulosa que era la gente que rodeaba a KDE. De esta forma llegué a la conclusión mientras conducía camino a casa que era un buen proyecto donde focalizar mis proyectos intereses personales y mis momentos de ocio.

Por eso me llena de alegría que KDE España siga realizando eventos de este tipo que no son más que unos excelentes momentos para compartir mucho más que conocimiento digital.

En fin, el escueto anuncio oficial, al que pronto le seguirán muchas más novedades, es el siguiente:

«La asociación KDE España anuncia la celebración de Akademy-es 2020 en Málaga, dentro del gran evento libre Opensouthcode del 24 al 26 de abril.»

Akademy-es 2020 se celebrará en Málaga

Foto de grupo de Akademy-es 2019 de Vigo.


 

Durante el evento, como es costumbre, se realizarán charlas tanto para usuarios como para desarrolladores, ademas de talleres prácticos y otras actividades de carácter más social con las que se pretenden cumplir los siguientes objetivos:

  • Poner en contacto a desarrolladores de KDE de toda España, para que puedan hablar de los proyectos en que están trabajando, compartir código, experiencias y conocimiento.
  • Dar a conocer los proyectos KDE como el entorno de escritorio nuevos usuarios.
  • Divulgar acerca de las tecnologías KDE, tanto para nuevos desarrolladores como para usuarios que quieran conocer mejor KDE.
  • Y por supuesto, el objetivo principal es que todos disfrutemos aprendiendo más sobre Software Libre y KDE.

 

¡Os esperamos!

 


So, today I got finally so tired of navigating (or explicitly stepping over) all the internal functions in gdb (you know, all the inline functions from STL containers, from Boost, from this pointer wrapper class, that string class) that I finally googled 'gdb skip system functions'. And guess what, it's been there since gdb 7.12, from 3 years ago, and it's almost trivial, just adding something like this to ~/.gdbinit:

skip -gfi /usr/include/*
skip -gfi /usr/include/*/*
skip -gfi /usr/include/*/*/*
skip -gfi /usr/include/*/*/*/*

 I feel so stu^H^H^Hproud for catching up only 3 years late.


We are excited to announce that KDE e.V. has received a donation of 880,000 HNS coins (roughly 79,000 euros) from the Handshake Foundation.

This is the not the first time Handshake has made a substantial donation to the KDE Community. Back in 2018 Handshake donated approximately 300,000 euros to KDE which was used to finance projects and fund activities.

"The Handshake Naming System is a child of the Open Source Community", says Andrew Lee from the Handshake Foundation. "Just like Handshake, KDE has championed privacy and freedom since the beginning and has paved the way forward in creating usable tools made for the masses.

"Personally, I've used KDE software since the early 2000s, and I've seen it grow and flourish. I think, many people today would be surprised to hear that Apple Safari, for example, was based originally on Konqueror, a web browser created by the KDE Community. The Handshake Naming System is proud to be able to make a donation to the KDE team. It is our way of showing appreciation for KDE, as much of the development in the Open Source world would not have been possible without it."

KDE would like to thank the Handshake Foundation for their continued generosity and the support they offer to FLOSS communities across the spectrum. This contribution will help KDE continue with its commitment to create Free Software for everyone, finance events and sponsor community members.

You can help KDE too! All you need to do is join the Community and be part of our mission to help people maintain their privacy and their control over their digital lives with Free Software.
---
Photo by Cytonn Photography on Unsplash.


With everyone getting back into work, we have managed to control the number of bugs. There are 2 fewer bugs than what I reported last time. I know it is still not a lot, but with Dmitry not available for most of the time and team having to divide its time between the resource rewrite & bug fixing, it is pretty good that the number is decreasing.


Have you ever noticed code highlighting disappearing in Qt Creator for some projects, without any apparent reason?

Can’t get Ctrl+Click to work on any class name or function name anymore?

Maybe you have ignored it at first, got used to it, and decided it’s just one of those things that just “happen sometimes”; or maybe you have tried opening other projects and seen everything was fine there.

Screenshots of broken and working syntax highlighting in Qt Creator

Broken vs working syntax highlighting in Qt Creator

My colleagues and I have been there ourselves, we know how puzzling this can be. Luckily enough, the issue is as elusive as it’s easy to fix.

Check your project and see if it falls into one of the following two scenarios:

1. You are using spaces in a compiler option

Some of Microsoft’s “cl” C++ compiler options have a syntax that allows for spaces between the option and its associated value, that is usually a directory or a file path. This is the case for other compilers too, think about -isystem /path/to/include/dir in GCC or Clang.

However, these parameters aren’t always well processed by Qt Creator, specifically when using the MSVC compiler; the rare examples where blanks are accepted work fine for GCC and Clang.

The only solution for this as I’m writing this post is to remove such spaces from compiler arguments.

So, for instance, if you are using /FI C:\force\included\file.h then you need to change it to /FIC:\force\included\file.h or even better /FI"C:\force\included\file.h" to avoid issues with paths containing spaces.

Note also that, although the official documentation doesn’t explicitly state it, some compiler options such as /wd xxxx and /we xxxx work fine even with a space between the option name and the compiler warning code. However, Qt Creator’s Clang code model will break also in this case.

2. You are using some “exotic” MSVC flags

Sometimes, even if no spaces are around, code highlighting may still be broken on your project.

This can happen if you’re using some options that aren’t currently handled by Qt Creator, but will be starting from Qt Creator 4.11.

One example above all is the set of experimental options such as /experimental:external and its companion options /external:I and /external:W.

The main reason why this is happening is that the option is passed to Clang to build the code model of the project being developed.Clang doesn’t support argument syntax starting with a forward slash (/), and will interpret such options as file names instead. These “files” won’t be found and clang will consequently fail to parse the codebase.

Note that some compiler options are already being ignored by Qt Creator itself, and therefore you don’t see the issue if you use for instance /wdxxxx, which is a valid cl option but not a Clang one. This is however not the case for the options mentioned above.

There are two ways to fix this:

  • Replace forward slash (/) with a dash (-) when passing the option to the compiler: this way Clang will correctly interpret it as a compiler option and if it doesn’t know it it will just ignore that option.
  • Add any option breaking your code model to the QTC_CLANG_CMD_OPTIONS_BLACKLIST environment variable. This way bad options won’t be forwarded to Clang at all and your code highlighting will be ok. For instance QTC_CLANG_CMD_OPTIONS_BLACKLIST=/experimental:external;/external:I;/external:W

You can see how the fixes work in real qmake and CMake projects in the screenshots below:

Screenshots of a qmake file which breaks syntax highlighting and one who doesn't

Bad vs good qmake file

Screenshots of a CMake file which breaks syntax highlighting and one who doesn't

Bad vs good CMake file

 

Did you find this post useful for a project you are working on? Have you ever had to deal with elusive bugs like this one? Let us know in the comments below!

About KDAB

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

Subscribe to KDAB TV for similar informative short video content.

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

The post Fix Qt Creator code highlighting on Windows/MSVC projects appeared first on KDAB.


We continue working on the plotting capabilities of LabPlot. In the next release we will be adding two new worksheet objects to provide more flexibility and features to create attractive looking visualizations. In this short blog post we want to report on this recent development.

Reference Line

Reference lines are placed on the plot to attract the attention to certain values and patterns in the visualized data. The reference lines can have both orientations, horizontal and vertical, to highlight x- and y-values. The lines can be positioned either by dragging with the mouse or, for a more precise positioning, by entering the exact position value in the properties widget of the reference line.

Image Element

The image element allows to add an image to the plot or to the worksheet. Several properties of the image like the size, position, the style of the border line and the opacity of the image can be adjusted to get the desired result.

Demo

The worksheet below demonstrates the usage of these two new objects. It shows some statistics about the amount of debris created and left floating in space since 1961:


Space Debris

The largest contributor to space debris is the breakup of satellites. The first plot shows the number of breakups starting with first occurring in 1961 and then all of the rest until 2018.

The next two plots show the density distribution of objects for near Earth altitudes as well as for the altitudes around the geosynchronous orbit.

The two red reference lines on the plot for the spatial density of objects for near Earth altitudes are used to highlight two peaks in the density distributions. These two peaks correspond to the accidental collision of Iridium 33 and Kosmos 2251 spacecrafts in 2009 and to the anti-satellite missile test conducted by China in 2007. These two events caused a substantial amount of debris at the corresponding altitudes.

The image elements besides the plots show the graphical distributions of the biggest trackable objects around the Earth.

The data is taken from History of On-Orbit Satellite Fragmentations provided by the NASA Orbital Debris Program Office (ODPO), the images are taken from ODPO’s gallery.


Wondering how the data for the spacial density was extracted from the PDF document provided by ODPO? Check out the the release announcement of 2.7 and the video demoing the recent improvements in LabPlot’s data picker – our tool to digitize the data values on images:



January 20, 2020

The last time I blogged about the Titler, I promised that the next update would be when we have some sort of a backend ready – and I’m happy to announce now that now we have some sort of a backend ready!

The QML MLT Producer

Testing

Find my MLT fork here 

Let us try to run it! Starting with something simple – take a sample QML file: test.qml

With the content –

import QtQuick 2.0

Item {
  Rectangle {
    id: rectangle
    x:0
    y: 0
    width: 155
    height: 160
    color: "#5cd037"
  }
}

After you have done building, run: melt qml:test.qml , we get:

rendered QML frame

and voila!

Which we can confirm (from running “qmlscene” on command line or from the Qt Designer Studio) which looks similar –

qmlscene rendered QML

And we can have images with fancier text and images, like this one I recently tried creating –

complicated QML frame

Although it’s not at animations yet, this works well enough for our initial testing.

A brief explanation

qml_wrapper files handle the generation of the rendered images.
In order to render images, this file makes use of QmlRenderer which has endpoints to render a QML file into a given QImage.

producer_qml.cpp is the main producer file.

When melt qml:test.qml is run, the registered producer (in this case, “qml”) is queried and initialised, and then a QApplication window with the rendered frames is launched and played ( which is what we see )

I refactored a lot of code in the QmlRenderer library comparing it with the code in the last blog post, for the convenience of the producer. For starters, only one method needs to be called for rendering now – render(&image). The constructor takes cares of the input file and other params (height, width, format) are fed in by the &image param.

What’s Next?

Test this producer in Kdenlive and see if we can play “qml” files in Kdenlive. So far, there are some issues with mishandling multiple OpenGL contexts and threading, which we are looking into right now. And if that goes well, we can then start worrying about the interface. We will let you know how it goes!

Will we have the new Titler for 20.04?

We don’t know yet. If the producer integration goes without major hiccups, 20.04 might or might not be a feasible deadline but we hope for the best.


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)".
[...]

Que el escritorio Plasma de la Comunidad KDE es increiblemente configurable es un hecho incontestable. Y desde hace unas cuantas versiones de Plasma todavía más ya que es posible descargar nuevos tipos de fondos de pantalla en nuestro escritorio. De esta forma se puede ampliar las opciones básicas como el color plano, la imagen fija o el carrusel de imágenes. Hoy me congratula compartir con vosotros uno más: Animated Image Wallpaper, el cual nos posibilita añadir animaciones a tu fondo de pantalla de una forma fácil, sencilla y, además, también configurable.

Animated Image Wallpaper, añade animaciones a tu fondo de pantalla

Hace unos mese os hablé de Video Wallpaper, un plugin con el que podíamos poder un vídeo como fondo de pantalla en Plasma. Era una opción muy interesante y, que según el vídeo a reproducir, consumía pocos recursos.

Hoy os quiero comentar otra opción, Animated Image Wallpaper otro plugin de fondo de pantalla creado por Dark-Eye con el que podemos poner imágenes animadas como fondo de pantalla y que soporta los formatos animado GIF, MNG y WEBP.

Además, dispone de una pocas opciones de configuración como son el desenfoque (blur), control de velocidad de animación y sombreado día/noche.

Animated Image Wallpaper, añade animaciones a tu fondo de pantalla

En mi caso me he animado a poner el clásico fondo de pantalla de letras de cromo verde cayendo sobre fondo negro que aparecía en la película «Matrix» y que tan fuerte pegó en su tiempo. Eso si, parece que el consumo de CPU se dispara según que fondo utilices.

Y por cierto, os dejo un enlace a una web donde se pueden descargar este tipo de fondos de pantalla.

Y como siempre digo, si os gusta Animated Image Wallpaper podéis “pagarlo” de muchas formas en la nueva página de KDE Store, que estoy seguro que el desarrollador lo agradecerá: puntúale positivamente, hazle un comentario en la página o realiza una donación. Ayudar al desarrollo del Software Libre también se hace simplemente dando las gracias, ayuda mucho más de lo que os podéis imaginar, recordad la campaña I love Free Software Day 2017 de la Free Software Foundation donde se nos recordaba esta forma tan sencilla de colaborar con el gran proyecto del Software Libre y que en el blog dedicamos un artículo.

Más información: KDE.Store


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

January 19, 2020

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.

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:

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

Bugfixes & Performance Improvements

User Interface Improvements

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.


January 18, 2020

KDE is running a competition in search of the next great promotional video for KDE's Plasma desktop and KDE's applications.

The prizes are two fantastic TUXEDO computers, one per category, which will undoubtedly boost your film rendering capacity. There are also 12 goodie packages for runner-ups, and who doesn't need more Linux shirts, caps and stickers?

Although we have already received some interesting entries, we feel it may be time to help video artists out there with ideas from the judges themselves.

Below, Julian Schraner, Ivana Isadora Devčić, and Paul Brown from the Promo team and Farid Abdelnour from the Kdenlive team give their views on what a KDE promotional video should look like, where to find resources, and which pitfalls may hurt your film if you fall for them.

Julian

I have five simple recommendations for participants:

  1. Avoid videos that contain only screencasts
  2. Break the mold, be creative
  3. Use motion graphics techniques (have a look at animation nodes)
  4. Choose a good catchy song and work on that editing
  5. Make it short, make sure there is something happening in every single frame. Cut out lulls -- they're boring

Ivana

Here's my list of things I would recommend doing, as well as what to avoid:

  • No slideshows, please! Don't make the video look like someone animated a PowerPoint presentation with zoomed-in screenshots sliding into view and fading out. That just looks cheap and low-effort.
  • Don't overdo it with memes and attempts at humor. As amusing as it may be to you and your 3 friends, things like that do not always translate well across cultures and generations. It's OK to add a cheeky moment if it's appropriate with the general theme of your video, but trying to make the entire video "funny" might send the message that you think Plasma is a joke.
  • It's OK to include real, actual people in the video. Anyone can easily make a screencast, but it takes effort - and shows that you made an effort! - to film people using Plasma. Including clips of people using Plasma can make a much stronger impact than just showing the desktop, even if the clips are short.
  • This is very, very basic and Captain Obvious-style, but: background music can have this cool thing called volume. Playing with volume can add depth and variety to your video. Make the background music louder in some parts and softer in others, depending on the effect you're trying to achieve. If it's always the same, the entire video can easily seem monotonous, even if it's only a minute long.
  • If possible, don't use computer-generated voices for voice-overs in the video (that is, if you're going to have any at all). 98% of them sound really fake and distract from the actual content, or just make the video sound boring. Even if you don't have a particularly radio-friendly voice, it will still sound more natural and normal if you record yourself (or try asking someone to help).
  • Great videos tell a story; they're not just a semi-connected list of clips with background music tacked on. Try to develop a little story that sends a specific message instead of just showing random Plasma features. It's also very easy to fall into the trap of comparing Plasma to something else and disparaging other DEs, so please try to avoid that.
  • Personally, I do not want to see "wobbly windows" in any of the videos. Plasma is more than just KWin effects; we're looking for videos that will make people think "wow, this could be really useful to me, I wanna try it", not "haha that's a cool gimmick, I bet I can move the mouse fast enough to break it".

Another important thing - if the video does have any narration/voice-over, I would ask that you include subtitles (at least as a separate file, if hard-coding them is a bad practice). Accessibility is a must!

Paul

I've split my recommendations into 3 parts: the footage you can use, the music (and other sounds), and the editing; that is, the raw materials and how you put them together.

Footage

Like Ivana, I would personally like to see some live action mixed in with the screencasts. You can grab your phone, and go and film something you can then work into the story. Or you can also take some public domain footage from the Internet Archive.

If you look at Real LifeTM advertisements, they don't only show the product, they also show people doing stuff with the product. Most of our videos are already a bunch of screencasts chained together. I want to see something different.

That said, when you do insert screencast footage, make sure you show something interesting happening in the applications. Don't show an empty folder in Dolphin, a blank square in Krita, or a boring, text-only document in Okular. Make sure there's some color in there and that you can see the user doing something.

As for footage of people, try to avoid stock footage, especially those clips that show smartly dressed white people looking at a computer screen, pointing and smiling. It's like the stock photos of women laughing at salads: you see that kind of stuff everywhere and it looks soooo fake. It is nearly as bad as stock music. Nearly...


"My salad is hilarious!"

Another thing to take into account is that you have to be careful with copyrights! Anything that has not been published before 1924 and doesn't have an explicit free license or isn't explicitly in the public domain, is under a regular copyright and may not be used without the authors' or the copyright holders' express written permission. Also, make sure the person distributing the work is the owner of the work. Don't blindly trust a random Youtuber!

TIP: Apart from the Internet Archive, many public institutions publish footage for free on the Internet. One such organization that comes to mind is NASA.

Music

The best way to make me switch off a video after a few seconds is by choosing the "wrong" music. Ironically, "the wrong music" is often that heartless, bland music used in nearly every single corporate video. I swear I would prefer to have hot wax poured into my ears rather than listen to another hokey, fake-quirky ukulele theme in my life.


The best kind of ukelele.

Conversely, sometimes what may seem the wrong music is in fact the right music. Stuff that you can't imagine going together, goes together. Salsa for Spectacle, flamenco for Falkon and power-pop for Plasma? Why not?

Again, be careful with copyrighted stuff. The same thing that applies to footage, applies to music. Besides, just because Johann Sebastian Bach died 300 years ago, doesn't mean that you can use that Von Karajan recording of his Cantatas: the recording itself will be copyrighted.

Most artists on Jamendo release their music under a liberal license as long it is not used for commercial purposes. And making a video for a competition organized by a non-profit that will not generate any money for you or for the non-profit IS NOT a commercial purpose. Also check out Free Music Archive and especially Juanitos: They make great, fun retro pseudo-ethnic music and distribute it under very generous terms.

On the other hand, go easy with Incompetech -- his music can be lovely, but it is EVERYWHERE. If you must use one of his tracks, make sure you poke around and go for his less obvious stuff.

TIP: If you need a voice-over but are not confident that your own voice will sound okay, try Fiverr. For a few dollars, you can have a professional actor read out your script.

Editing

Avoid canned transitions that come as standard with your video-editing software (Kdenlive, right?). They may impress your parents, but everybody else thinks they're lazy.

Related to the above, avoid excessively flashy transitions, even if they are original. I am personally guilty of using animations to transition from one scene to another, but if they are not part of the story, they can draw attention to themselves and away from the real content, distracting the viewer. Most of the time, nothing beats a good clean cut.

The same goes for effects: don't overdo them! Effects are great to confer atmosphere, but if they are not doing that, they are just distracting from the story, and more often than not, make the action harder to follow. Here's looking at all those "editors" that place a screencast into the picture of a monitor! Yes, I get it: you do masks. So does everybody.

TIP: If you do need effects for your video, don't limit yourself to the catalogue supplied by your editing software. Check out things like Blender and Natron -- these programs are used a lot for effects and filters for a reason.

Farid

Apart from everything mentioned above, I would encourage participants to look into using motion graphic techniques rather than sticking to simple transitions when possible. For that, you can use tools like Blender's Animation Nodes addon.

Something that is often overlooked is the matter of typography. Choose your fonts wisely! If you have text on the screen, avoid the default bland fonts. Go to Font Squirrel or Google Fonts for a great selection of free and open types to choose from.


Same goes for video titles.

If you need footage, check out Pexels it contains a lot of high quality clips for free.

About KDE's Video Contest

KDE is looking for talented videographers and filmmakers that will help promote our free software through the medium of video. There are two categories in this contest: in the Plasma category we want participants to create a video that will promote KDE's Plasma desktop to the world. The Applications category is to help promote one or several KDE applications.

Submissions must be sent in before the 20th of February 2020. To find out more, check out the full rules.


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. 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.

A Deutsche Bahn train ticket display in Nextcloud Mail (screenshot by Nextcloud). 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!


January 17, 2020

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


January 16, 2020

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?




Plasma 5.18 LTS Beta

KDE Plasma 5.18 LTS Beta

Thursday, 16 January 2020.

The Plasma 5.18 LTS Beta is out!

This new version of your favorite desktop environment adds neat new features that make your life easier, including clearer notifications, streamlined settings for your system and the desktop layout, much improved GTK integration, and more. Plasma 5.18 is easier and more fun, while at the same time allowing you to do more tasks faster.

Apart from all the cool new stuff, Plasma 5.18 also comes with LTS status. LTS stands for "Long Term Support" and this means 5.18 will be updated and maintained by KDE contributors for the next couple of years (regular versions are maintained for 4 months). So, if you are thinking of updating or migrating your school, company or organization to Plasma, this version is your best bet. You get the most recent stable version of Plasma for the long term.

Read on to discover everything that is new in Plasma 5.18 LTS…

Plasma



Emoji Selector

Emoji Selector


Customize Layout Global Settings

Customize Layout Global Settings



GTK Apps with CSD and Theme support

GTK Applications with CSDs and Theme Integration


Night Color System Tray Widget

Night Color System Tray Widget
  • Emoji Selector that can be opened through the application launcher or with the Meta + . keyboard shortcut
  • New global edit mode which replaces the desktop toolbox button and lets you easily customize your desktop layout
  • Improved touch-friendliness for the Kickoff application launcher and widget editing
  • Support for GTK applications which use Client Side Decorations, adding proper shadows and resize areas for them
  • GTK apps now also automatically inherit Plasma's settings for fonts, icons, cursors and more.
  • There's a new System Tray widget for toggling the Night Color feature and by default it automatically appears when it's on
  • More compact design to choose the default audio device in the Audio Volume System Tray widget
  • Clickable volume indicator and tooltip item highlight indicators in the Task Manager
  • Circular Application Launcher menu user icon
  • Option to hide the lock screen clock
  • It's now possible to configure keyboard shortcuts that turn Night Color and Do Not Disturb mode on or off
  • Windy conditions shown in weather widget


Notifications



Draggable Download File Icon

Draggable Download File Icon


Low Bluetooth Battery

Bluetooth Device Battery Low Notification

  • The timeout indicator on notification popups has been made circular and surrounds the close button
  • A draggable icon in the "file downloaded" notification has been added, so you can quickly drag it to places
  • Plasma now shows you a notification warning when a connected Bluetooth device is about to run out of power


System Settings



User Feedback

User Feedback

Application Style

Application Style

  • Plasma gained optional User Feedback settings (disabled by default), allowing you to give us detailed system information and statistics on how often individual features of Plasma you use
  • Added a slider for the global animation speed
  • Redesigned Application Style settings with a grid view
  • Improved the search in the system settings sidebar
  • An option to scroll to clicked location in the scrollbar track has been added
  • The System Settings Night Color page has a clearer user interface now


Discover



Reading and Writing Review Comments

Reading and Writing Review Comments

  • Discover's default keyboard focus has been switched to the search field
  • It's now possible to search for add-ons from the main page
  • Added nested comments for addons
  • Made design improvements to the sidebar header and reviews


More



NVIDIA GPU stats

NVIDIA GPU stats

  • Decreased the amount of visual glitches in apps when using fractional scaling on X11
  • Made it possible to show NVIDIA GPU stats in KSysGuard


New Since 5.12 LTS

For those upgrading from our previous Long Term Support release here are some of the highlights from the last two years of development:

  • Completely rewritten notification system
  • Plasma Browser Integration
  • Many redesigned system settings pages, either using a consistent grid view or just an overhauled interface
  • Global menu support for GTK applications
  • Display Management improvements including new OSD and widget
  • Flatpak portal support
  • Night Color feature
  • Thunderbolt Device Management

Full Plasma 5.18 LTS Beta changelog


Live Images

The easiest way to try it out is with a live image booted off a USB disk. Docker images also provide a quick and easy way to test Plasma.

Download live images with Plasma 5
Download Docker images with Plasma 5

Package Downloads

Distributions have created, or are in the process of creating, packages listed on our wiki page.

Get KDE Software on Your Linux Distro wiki page

Source Downloads

You can install Plasma 5 directly from source.

Community instructions to compile it
Source Info Page

Feedback

Discuss Plasma 5 on the KDE Forums Plasma 5 board.

You can provide feedback direct to the developers via the Plasma Matrix chat room, Plasma-devel mailing list or report issues via bugzilla. If you like what the team is doing, please let them know!

Your feedback is greatly appreciated.


KDE Connect Website

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.

Kdenlive

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. Developer

Downloads

DeveloperBlog

UserSupport

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!!”


January 15, 2020

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.
Configuration of variables in an attachment name in a KMail snippet. 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 feed tree view showing feed icons. 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



Plasma desktop with a Windows 10-like theme.

Today Microsoft has left Windows 7 users behind.

Redmond will no longer provide updates for the 2009 operating system. This puts almost a billion people in the difficult situation of facing increased security risks alongside a slow decline in software availability.

Folks who reject Microsoft’s forced updates are already opting to regain control over their systems by switching to the friendly and full-featured Plasma desktop, built on a design philosophy which centers freedom and respect for its users. Recent buzz about the possibilities of Plasma has brought a lot of fresh faces on board, and now they are trying to navigate a new operating system that has its differences from Windows.

If you’re one of those people, you’re probably wondering where you can find experienced users to help you get settled in.

How to make the jump with ease

Luckily, there is a wealth of resources available for those new to Plasma and the Linux world.

The best place to talk live with Plasma users, ask questions, and get to know the KDE community is the KDE Welcome room on our webchat or on Matrix. If you want to discuss Plasma and comment on the latest KDE news with other users, find r/KDE on Reddit or check out the official KDE forums.

AskUbuntu.com is the largest dedicated tech support site in the Linux world, and an invaluable resource for anyone using KDE Neon or Kubuntu. Much of the info available here even translates well to other Linux flavors. Other places for specific support questions include r/Linux4Noobs and r/LinuxQuestions on Reddit. Talking of which, another great resource is the Linux Questions forums.

Once you have a little bit of experience under your belt, if you run into trouble with a specific system component, you can always resort to the Arch Linux wiki, an in-depth hub of documentation which is often useful to users of any Linux system.

Everyone in the KDE community is familiar with the hurdles new users face when making the jump to Plasma and the Free Software world. Don’t hesitate to take advantage of KDE's welcoming community who will help you feel right at home in Plasma and make sure you get the most out of your newly upgraded system.


January 14, 2020

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. But one of those releases was 4.2.0, which made HDR editing available to artists for the first time; no other application supported that when 4.2.0 was released in May.

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).


January 13, 2020

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.

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



Older blog entries