January 20, 2019

I got a bit traction on KookBook and decided to fix a few bugs, mostly in the touch client, and add some features.

Get it here: kookbook-0.2.0.tar.xz

KookBook is now also available in Debian, thanks to Stuart Prescott

KRecipe converter
Some people has a large recipe collection in KRecipe and would like to try out KookBook. I wrote a convertion python script now available. It works in “current directory” and reads the krecipe database from there and outputs KookBook markdown files in same repository. It has so far been tried on 1 database.

Bug fixes

  • Fix install of touch client
  • Fixes in desktop files
  • Fixes in touch client’s file open dialog
  • Touch client now show images in recipes
  • You could end up with no dock widgets and no toolbar and no way to recover in the desktop client. This is now fixed
  • Build fixes

Future
Some people have started talking about maybe translation of the interface. I might look into that in the future.

And I wouldn’t be sad if some icon artists provided me with a icon slightly better than the knife I drew. Feel free to contact me if that’s the case.

Happy kooking!

Y llegamos al número mágico. Con Sol para Plasma 5 llegamos a los 100 plasmoides para nuestro entorno de trabajo favorito. Este plasmoide se une al elenco de delicias visuales astronómicas que podemos incorporar a nuestro escritorio como Gealach.

Sol para Plasma 5 – Plasmoides de KDE (100)

Mucho ha llovido desde que en octubre del 2008 inicié la sección de plasmoides de KDE con el reloj analógico hasta llegar al número 100 con Sol. Y es que la posibilidades de personalización del escritorio de KDE son infinitas pudiendo desde simplemente decorarlo a añadir funcionalidades extra o simplemente mejorar la accesibilidad a muchas de las opciones que nos ofrece Plasma.

Para este plasmoide número 100 os presento Sol, una creación de The Vlad Soft, un plasmoide muy simple que nos coloca una imagen del Sol proporcionada por Dynamics Observatory con actualizaciones cada 30 minutos.

Sol para Plasma 5 – Plasmoides de KDE (100)

Pero no esperéis ver un Sol siempre amarillo, sino que Dynamic Observatory nos ofrece la posibilidad de verlo en forma con diferentes filtros, tal y como vemos en sus opciones de configuración.

La instalación de Sol se realiza desde “Obtener más widgets” del propio escritorio Plasma, así que no hay dificultad ninguna para tenerlo decorando nuestro escritorio.

Y como siempre digo, si os gusta el plasmoide 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

 

¿Qué son los plasmoides?

Para los no iniciados en el blog, quizás la palabra plasmoide le suene un poco rara pero no es mas que el nombre que reciben los widgets para el escritorio Plasma de KDE.

En otras palabras, los plasmoides no son más que pequeñas aplicaciones que puestas sobre el escritorio o sobre una de las barras de tareas del mismo aumentan las funcionalidades del mismo o simplemente lo decoran.

In the last few days I've been writing a simple website for Imaginario. I'm a terrible site designer, and I can't really say that I enjoy writing websites, but it's something that from time to time people might need to do. While the PhotoTeleport website is built with Jekyll, this time I decided to try some other static site generator, in order to figure out if Jekyll is indeed the best for me, or if there are better alternatives for my (rather basic) needs.

I set out trying a couple of Python-based generators, Pelican and Nikola. Here is a brief review of them (and of Jekyll), in case it helps someone else make their own choice.

Jekyll

I've been using it since several months for the PhotoTeleport website, which features a news section and a handful of static pages. It does the job very well and I haven't any major complaint. It's very popular and there are plenty of plugins to customize its behaviour or add new functionality. The documentation is sufficient for a basic usage of the site, and information on how to solve more specific issues can easily be found in the internet.

My only issue is that it's not totally intuitive to use, and in order to customize the interactions for your own needs you need to write your own scripts — at least, I didn't find a ready solution to create a new post, or deploy the generated content into my site.

Pelican

My first impression with Pelican has been extremely positive: it's very easy to setup and start a blog. It's also quite popular, even though not as much as Jekyll, and there are may themes for it. By looking at the themes, though, I quickly realized that Pelican is meant to be used for blogs, and not for simple static sites. I'm almost sure that there must be a way to use it to create a static site, maybe with some tweaking, but I couldn't find information about this in its documentation. A quick search in the internet didn't help either, so I gave up and moved to the next one.

If I had to write a blog I'd certainly consider it, though.

Nikola

Nikola is definitely less popular than Jekyll or Pelican, at least if we trust the number of stars and forks in GitHub, but it's still a popular and maintained project, with many plugins. Like Jekyll, it can handle both blogs and sites, or a combination of the two. It's well documented, the people in the forum are helpful, and its command line interface is simpler and more intuitive than Jekyll's. Also, the live preview functionality seems to be more advanced than Jekyll's, in that the browser is told to automatically reload the page whenever the site is rebuilt.

You can see my progress with the Imaginario website by inspecting the commits in its repository; you'll see how easy it was to set it up, and hopefully following my steps you'll save some time should you decide to create your own site with Nikola.

Overall, I'd rate Jekyll and Nikola on the same level: Jekyll wins for the wider community and amount of available plugins, while Nikola wins for the better command line interactions, and the fact that it's in Python gives me better confidence should I ever need to modify it deeply (though, admittedly, the latter is just a personal preference — Ruby developers will say the opposite).

This week in KDE’s Usability & Productivity initiative, something big landed: virtual desktop support on Wayland, accompanied by a shiny new user interface for the X11 version too. Eike Hein, Marco Martin, and the rest of the Plasma hackers have been working on this literally for months and I think they deserves a round of applause! It was a truly enormous amount of work, but now we can benefit for years to come. ��

We’ve also started the Plasma 5.15 beta period. Go test it: https://blog.neon.kde.org/index.php/2019/01/17/test-kde-plasma-5-15-beta-with-neon/

Bug reports have already started to come in and we’re fixing them as fast as possible to ensure a smooth release next month on February 12th!

New Features

Bugfixes & Performance Improvements

User Interface Improvements

Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal. Also consider making a donation to the KDE e.V. foundation.

January 19, 2019

I recently configured Travis CI to build Nanonote, my minimalist note-taking application. We use Jenkins a lot at work, and despite the fact that I dislike the tool itself, it has proven invaluable in helping us catch errors early. So I strongly believe in the values of Continuous Integration.

When it comes to CI setup, I believe it is important to keep your distances with the tool you are using by keeping as much setup as possible in tool-agnostic scripts, versioned in your repository, and making the CI server use these scripts.

Ensuring your build scripts are independent of your CI server gives you a few advantages:

  • Your setup is easier to extend and debug, since you can run the build scripts on your machine. This is lighter than running an instance of your CI server on your local machine (nobody takes the time to do that anyway) and more efficient than committing changes in a temporary branch then wait for your CI server to build them to see if you got it right (everybody does that).

  • It keeps the build instructions next to your code, instead of being stored in, say, Jenkins XML file. This ensures that you can add dependencies and adjust the build script in one commit. It also ensures that if your build script evolves, you can still build old branches on the CI server (for example because you have a fix to do on a released version).

  • If your CI server is Jenkins or something similar, you spend less time cursing against the slow web-based UI (yes, I know about Jenkins Pipelines, but those have other problems...).

  • It is easier to switch to another CI server.

With this in mind, here is how I configured Nanonote CI.

Create a Build environment using Docker

The first element is to create a stable build environment. To do this I created a Docker with the necessary build components. Here is its Dockerfile, stored in the ci directory of the repository:

FROM ubuntu:18.04

RUN apt-get update \
    && apt-get install -y -qq --no-install-recommends \
        cmake \
        dpkg-dev \
        file \
        g++ \
        make \
        ninja-build \
        python3 \
        python3-pip \
        python3-setuptools \
        qt5-default \
        qtbase5-dev \
        qttools5-dev \
        rpm \
        xvfb

COPY requirements.txt /tmp

RUN pip3 install -r /tmp/requirements.txt

ENTRYPOINT ["/bin/bash"]

Nothing really complicated here, but there are a few interesting things to point out nevertheless.

It installs dpkg-dev and rpm packages, so that CPack can build .deb and .rpm packages.

It also installs the xvfb package, to be able to run tests which require an X server.

Finally it copies a requirements.txt file and pip install it. This is to install qpropgen dependencies. This requirements.txt is in 3rdparty/qpropgen, which Docker cannot reach (because it only sees files inside the ci directory), so I created a simple ci/build-docker script to build the Docker image:

#!/bin/sh
set -ev
cd $(dirname $0)
cp ../3rdparty/qpropgen/requirements.txt .
docker build -t nanonote:1 .

This gives us a clean build environment, now lets create a build script.

The build script

This script is ci/build-app. Its job is to:

  1. Create a source tarball
  2. Build and run tests from this source tarball
  3. Build .rpm and .deb packages

You may wonder why the script creates a source tarball, since GitHub automatically generates them when one creates a tag. There are two reasons for this:

  1. GitHub tarballs do not contain repository submodules, making them useless for Nanonote.
  2. I prefer to rely on my own build script to generate the source tarball as it makes the project less dependant on GitHub facilities, should I decide to move to another git host service.

Reason #1 also explains why the script builds from the source tarball instead of using the git repository source tree: it ensures the tarball is not missing any file necessary to build the app.

I am not going to include the script here, but you can read it on GitHub.

Travis setup

Now that we have a build script and a build environment, we can make Travis uses them. Here is Nanonote .travis.yml file. As you can see, it is just a few lines:

dist: xenial
language: minimal

services:
- docker

install:
- ci/build-docker

script:
- docker run -v $PWD:/root/nanonote nanonote:1 /root/nanonote/ci/build-app

Not much to say here: - We tell Travis to use an Ubuntu Xenial (16.04) distribution and Docker. - The "install" step builds the Docker image. - The "script" step mounts the source tree inside the Docker image and runs the build script.

Travis runs this on all branches pushed to GitHub. I configured GitHub to refuse pushes to the master branch if the commits have not been validated by Travis. This rule applies to all project contributors, including me. Since there is not (for now?) a large community of contributors to the project, I don't open pull requests: I just push commits to the dev branch, once Travis has checked them, I merge dev into master.

Releases

When it's time to create a release, I just do what Travis does: rebuild the Docker image then run the build script inside it.

Since the source tree is mounted inside the Docker image, I get the source and binary packages in the dist directory of the repository, so I can test them and publish them.

Travis has a publication system to automatically attach build artefacts to GitHub releases when building from a tag, but I prefer to build them myself because that gives me the opportunity to test the build artefacts before tagging and it prevents me from becoming too dependent on Travis service.

Conclusion

That's it for this description of Nanonote CI setup. It's still young so I might refine it, but it is already useful. I am probably going to create similar setups for my other C++ Qt projects.

I hope it helped you as well.

Hoy quisiera destacar el sobresaliente trabajo de los estudiantes de KDE durante el Google Code In 2018 que han realizado en la pasada edición y que han dejado una gran huella gracias a su trabajo guiado por los mentores de la Comunidad KDE.

Sobresaliente trabajo de los estudiantes de KDE durante el Google Code In 2018

Para los que no lo sepan Google Code-In es la competición anual de programación promocionado por Google Inc. Este programa permite a los estudiantes pre-universitarios completar tareas especificas seleccionadas por varias organizaciones de proyectos libres como KDE.

En el Google Code-In no se necesitan conocimientos específicos de programación ya que se les puede orientar en tareas de publicación de artículos en blogs o documentación, por mencionar solo un par de posibilidades. No obstante, algunos estudiantes pueden participar en el desarrollo del código si tienen suficientes conocimiento para ello.

Sobresaliente trabajo de los estudiantes de KDE durante el Google Code In 2018

Este año la participación de KDE ha sido un éxito para todos ya que se ha conseguido atraer a un gran número de participantes, lo cual siempre es una gran noticia, que no solo han mejorado el aspecto documental del proyecto sino que han ayudado a arreglar errores y agregar nuevas funcionalidades.

Por otra parte, los estudiantes se han llevado una gran experiencia y han empezado a conocer la metodología de trabajo en el desarrollo de un proyecto de Software Libre.

No ha sido fácil para los mentores seleccionar a los ganadores ya que todos los estudiantes han realizado un gran trabajo. No obstante, se debía tomar una decisión y finalmente se han seleccionado Pranav y Triplequantum (sus GCI nombres), mientras que TURX, TUX, UA y Waleko fueron los finalistas.

Evidentemente la Comunidad KDE está muy satisfecha por la participación de los estudiantes y da la enhorabuena a los ganadores en particular y a todos el alumnado en general.

Vía: Artículo de Pranam Lashkari en el dot de KDE

January 17, 2019

TL;DR, I’ll be switching to releasing new wallpapers every second Plasma release, on even-numbered versions.

This is just a post to refer to for those who have asked me about Plasma 5.15 and a new wallpaper. Since I started working on Plasma 5 wallpapers, there has always been a number of factors determining how exactly I made them. After some agonising debate I’ve decided to slow the wallpaper release pace, because as time has gone on a number of things have changed since I started contributing them:

Bugs & Releases. One of the early goals for wallpapers was to have one for each release so developers could identify versions of Plasma in screenshots of bug reports. This has become far less important, as issues have gone from “the bug causing everyone’s machines to catch fire while eating kittens” to things like “maybe stealing your left sock from the dryer”. Back in the day most distros didn’t offer rolling release options, so users would be reporting the bugs and sharing screenshots of old buggy versions. That, too, has changed; not only are rolling release options more plentiful, but standard release distros are well passed the dark days of immature Plasma 5. All said and done, we just don’t need wallpapers for developers to identify problem releases anymore; the bugs are far less severe and people are more up-to-date.

LTS Plasma versions & quality. While it may seem irrelevant to wallpapers, LTS stands out to as the place where we really need to pour love and care into our designs. With each new wallpaper I’m pushing things a bit harder and a bit further which means taking more time to create them, and I’m realising that at the quality I want to drive out LTS wallpapers with, it might take 3 to 5 dedicated days to produce a final product. That’s not including post-reveal tweaks I do after receiving feedback, or the wallpapers I discard during the creation process (for each wallpaper released, it’s likely I got halfway through 2 other designs). In other words, it’s becoming less sustainable.

The wallpapers aren’t crap anymore. It’s no secret, my first wallpapers were rough. When a new wallpaper was finished there were real quality incentives for me to take the lessons learned and turn-around a better wallpaper. Nowadays though most new wallpapers are visually pleasing and people don’t mind if they stick around for a bit longer. I know a lot of people even go back to previous wallpapers. Adding to this, it’s gotten easy to get older wallpapers; OpenDesktop, GetHotNewStuff both serve as easy access, and we now have some of the most popular default wallpapers in the extended wallpapers package. While new wallpapers are always nice to have, it’s no longer bad to keep what we’ve got.

Between those big three points, it brings me to moving the wallpaper cycle to every second Plasma release. New wallpapers will fall on even-numbered Plasma releases, landing squarely on the LTS releases and a feature release directly between LTS’s. That being said I hope that future wallpapers will show quality reflecting what the additional time will afford me to do.

KDE’s flagship project Plasma has a new beta out. There’s now three weeks to sort out the bugs to make the release a work of perfection.  We need your help.

Plasma has a new testing release out with a final release due in three weeks. We need your help in testing it and reporting problems.

KDE neon Developer Git-Stable Edition now has Plasma 5.15 beta and can be used for testing.

You can either download an ISO and install it or run it on a virtual machine. https://neon.kde.org/download

Or you can run the Docker image which should work on any Linux distro. https://community.kde.org/Neon/Docker

Please have a look over the new features and give them a try https://www.kde.org/announcements/plasma-5.14.90.php

You can report success or failure on the forum thread for Plasma 5.15 beta here or directly on the bug tracker at https://bugs.kde.org

Plasma 5.15 Beta in Virtualbox

Plasma 5.15 beta in Docker

En esta quinta temporada de los podcast de KDE España se ha iniciado una serie dedicada a las aplicaciones dedicadas al arte. El episodio 05×04 estuvo centrado en KDE y software para el arte I: imagen donde se explicó como la Comunidad KDE pone su granito de arena para ayudar a los artistas digitales y en el que quedó pendiente una entrevista a Alberto Flores, colaborador del proyecto Krita y artista aficionado. Es el momento de subsanar esa deuda.

Entrevista a Alberto Flores – 05×04.1 KDE y software para el arte I: imagen

No es lo más habitual, pero el podcast 05×04 KDE y software para el arte I: imagen tenía pendiente un epílogo: una entrevista a Alberto Flores, colaborador del proyecto Krita y artista aficionado, sobre el software de KDE, y libre en general, para el arte, en concreto para la imagen.

Durante 40 minutos Alberto nos explica su flujo de trabajo habitual, sobre el estado de Krita, Inkscape y otras aplicaciones de este sector.

Para finalizar hablamos también sobre comunidades de creadores libres donde, además de intercambiar opiniones, ofrecen recursos de forma libre. Estas son algunas de ellas:

Los participantes del podcast fueron:

  • Rubén Gómez Antolí, presentador del podcast y miembro de HackLab de Almería.
  • Alberto Flores, colaborador del proyecto Krita y artista aficionado

 

 

Espero que os haya gustado, si es así ya sabéis: “Manita arriba“, compartid y no olvidéis visitar y suscribiros al  canal de Ivoox de los podcast de KDE España

Como siempre, esperamos vuestros comentarios que os aseguro que son muy valiosos para los desarrolladores, aunque sean críticas constructivas (las otras nunca son buenas para nadie). Así mismo, también nos gustaría saber los temas sobre los que gustaría que hablásemos en los próximos podcast.

Aprovecho la ocasión para invitaros a suscribiros al canal de Youtube de KDE España.que pronto estará al día.



Plasma 5.15 Beta

KDE Plasma 5.15 Beta

Today KDE launches the beta release of Plasma 5.15.

For the first release of 2019, the Plasma team has embraced KDE's Usability & Productivity goal. We have teamed up with the VDG (Visual Design Group) contributors to get feedback on all the papercuts in our software that make your life less smooth, and fixed them to ensure an intuitive and consistent workflow for your daily use.

Plasma 5.15 brings a number of changes to our configuration interfaces, including more options for complex network configurations. Many icons have been added or redesigned. Our integration with third-party technologies like GTK and Firefox has been made even more complete. Discover, our software and add-on installer, has received a metric tonne of improvements to help you stay up-to-date and find the tools you need to get your tasks done.

Please test this beta release and send us bug reports and feedback. The final release will be available in three weeks' time.

Browse the full Plasma 5.15 Beta changelog to learn more about other tweaks and bug fixes included in this release:


New in Plasma 5.15 Beta

Plasma Widgets



    Bluetooth Battery Status

    Bluetooth Battery Status
  • Bluetooth devices now show their battery status in the power widget. Note that this cutting-edge feature requires the latest versions of the upower and bluez packages.
  • It’s now possible to download and install new wallpaper plugins straight from the wallpaper configuration dialog.
  • Filenames on desktop icons now have enough horizontal space to be legible even when their icons are very tiny, and are easier to read when the wallpaper is very light-colored or visually busy.
  • Visually impaired users can now read the icons on the desktop thanks to the newly-implemented screen reader support for desktop icons.
  • The Notes widget now has a 'Transparent with light text' theme.
  • It's now possible to configure whether scrolling over the virtual desktop Pager widget will “wrap around” when reaching the end of the virtual desktop list.
  • The padding and appearance of notification pop-ups have been improved.
  • KRunner has received several usability improvements. It now handles duplicates much better, no longer showing duplicate bookmarks from Firefox or duplicate entries when the same file is available in multiple categories. Additionally, the layout of the standalone search widget now matches KRunner's appearance.
  • The Devices Notifier is now much smarter. When it's configured to display all disks instead of just removable ones, it will recognize when you try to unmount the root partition and prevent you from doing so.


Settings



    Redesigned Virtual Desktop Settings

    Redesigned Virtual Desktop Settings
  • System Settings Virtual Desktops page has been redesigned and rewritten for support on Wayland, and now sports greater usability and visual consistency.
  • The user interface and layout for the Digital Clock and Folder View settings pages have been improved to better match the common style.
  • Many System Settings pages have been tweaked with the goal of standardizing the icons, wording, and placement of the bottom buttons, most notably the “Get New [thing]…” buttons.
  • New desktop effects freshly installed from store.kde.org now appear in the list on the System Settings Desktop Effects page.
  • The native display resolution is now indicated with a star icon in the System Settings Displays page.
  • The System Settings Login Screen page received plenty of visual improvements. The image preview of the default Breeze theme now reflects its current appearance, the background color of the preview matches the active color scheme, and the sizes and margins were adjusted to ensure that everything fits without being cut off.
  • The System Settings Desktop Effects page has been ported to QtQuickControls 2. This fixes a number of issues such as bad fractional scaling appearance, ugly dropdown menu checkboxes, and the window size being too small when opened as a standalone app.


Cross-Platform Integration



    Firefox with native KDE open/save dialogs

    Firefox with native KDE open/save dialogs
  • Firefox 64 can now optionally use native KDE open/save dialogs. This is an optional, bleeding-edge functionality that is not yet included in any distribution. However, it can be enabled by installing the xdg-desktop-portal and xdg-desktop-portal-kde packages and setting GTK_USE_PORTAL=1 in Firefox's .desktop file.
  • Integration modules xdg-desktop-portal-kde and plasma-integration now support the Settings portal. This allows sandboxed Flatpak and Snap applications to respect your Plasma configuration - including fonts, icons, widget themes, and color schemes - without requiring read permissions to the kdeglobals configuration file.
  • The global scale factor used by high-DPI screens is now respected by GTK and GNOME apps when it’s an integer.
  • A wide variety of issues with the Breeze-GTK theme have been resolved, including the inconsistencies between the light and dark variants. We have also made the theme more maintainable, so future improvements will be much easier.


Discover



    Distro Release Upgrade Notification

    Distro Release Upgrade Notification
  • Options for upgrading your distribution are now included in Discover’s Update Notifier widget. The widget will also display a “Restart” button if a restart is recommended after applying all updates, but the user hasn’t actually restarted yet.
  • On Discover’s Updates page, it’s now possible to uncheck and re-check all available updates to make it easier to pick and choose the ones you want to apply.
  • Discover’s Settings page has been renamed to “Sources” and now has pushbuttons instead of hamburger menus.
  • Distribution repository management in Discover is now more practical and usable, especially when it comes to Ubuntu-based distros.
  • Discover now supports app extensions offered with Flatpak packages, and lets you choose which ones to install.
  • Handling for local packages has been improved, so Discover can now indicate the dependencies and will show a 'Launch' button after installation.
  • When performing a search from the Featured page, Discover now only returns apps in the search results. Add-ons will appear in search results only when a search is initiated from an add-on category.
  • Discover’s search on the Installed Apps page now works properly when the Snap backend is installed.
  • Handling and presentation of errors arising from misconfigured add-on repos has also been improved.
  • Discover now respects your locale preferences when displaying dates and times.
  • The “What’s New” section is no longer displayed on app pages when it doesn't contain any relevant information.
  • App and Plasma add-ons are now listed in a separate category on Discover’s Updates page.


Window Management

  • The Alt+Tab window switcher now supports screen readers for improved accessibility, and allows you to use the keyboard to switch between items.
  • The KWin window manager no longer crashes when a window is minimized via a script.
  • Window closing effects are now applied to dialog boxes with a parent window (e.g. an app’s Settings window, or an open/save dialog).
  • Plasma configuration windows now raise themselves to the front when they get focus.


Wayland

  • More work has been done on the foundations - the protocols XdgStable, XdgPopups and XdgDecoration are now fully implemented.
  • Wayland now supports virtual desktops, and they work in a more fine-grained way than on X11. Users can place a window on any subset of virtual desktops, rather than just on one or all of them.
  • Touch drag-and-drop is now supported in Wayland.


Network Management



    WireGuard VPN Tunnels

    WireGuard VPN Tunnels

  • Plasma now offers support for WireGuard VPN tunnels when the appropriate Network Manager plugin is installed.
  • It’s now possible to mark a network connection as “metered”.


Breeze icons

Breeze Icons are released with KDE Frameworks but are extensively used throughout Plasma, so here's a highlight of some of the improvements made over the last three months.



    Icon Emblems in Breeze

    Icon Emblems in Breeze
  • A variety of Breeze device and preference icons have been improved, including the multimedia icons and all icons that depict a stylized version of a Plasma wallpaper.
  • The Breeze emblem and package icons have been entirely redesigned, resulting in a better and more consistent visual style, plus better contrast against the icon they’re drawn on top of.
  • In new installs, the Places panel now displays a better icon for the Network place.
  • The Plasma Vault icon now looks much better when using the Breeze Dark theme.
  • Python bytecode files now get their own icons.


Other



    KSysGuard’s optional menu bar

    KSysGuard’s optional menu bar
  • It’s now possible to hide KSysGuard’s menu bar — and it reminds you how to get it back, just like Kate and Gwenview do.
  • The plasma-workspace-wallpapers package now includes some of the best recent Plasma wallpapers.



Live Images

The easiest way to try out Plasma 5.15 beta 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.

Package download 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 IRC channel, 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.

January 16, 2019

After many years of successful Google Code-in participation, this year we did it again! KDE attracted a number of students with exciting tasks for their eager young minds.

Google Code-in is a program for pre-university students aged from 13 to 17 and sponsored by Google Open Source. KDE has always worked to get new people involved in Free and open source (FOSS) projects with the aim of making the world a better place.

This year was no different. Our students worked very hard, and some of them already have their contributions committed to the KDE codebase!

We designed tasks in a way that made them exciting for all students. Students who were not skilled in programming took on tasks of writing blogs or documentation. To help students who had no experience with FOSS or with the community, we set up introductory tasks for IRC and mailing lists, both of which are essential in FOSS as communication channels.

The students who had some prior programming experience received tutorial tasks to get a better understanding of how KDE software works. Those types of tasks also helped them become familiar with the Qt framework on which all KDE software is based. Finally, students good at programming were put to work contributing to on-going KDE projects. They created new features or solved known bugs and wrote unit tests.

We’re happy that some really enthusiastic and persistent students joined us this year. Thanks to their passion for programming, they completed many tasks and delivered quality code we merged into our project repositories.

It wasn’t easy for the mentors to select winners, as every student had accomplished great things. Still, we finally settled on pranav and triplequantum (their GCI names). Finalists were TURX, TUX, UA and waleko.

KDE would like to congratulate all the winners and finalists, and we warm-heartedly welcome all our new contributors!

Author: Pranam Lashkari

January 13, 2019

Facebook’s AccountKit is an authentication service that can use your email or phone number to login to your services, it doesn’t require that the user has a Facebook account, just a valid email or phone.

The cool thing about it is that it sends SMS for free, and although sending SMSs is cheap being free of charge is something you might want to look when creating a new App, in fact here in Brazil some big Apps do make use of it.

So long story short story I wanted to add this to my Qt Android App.

Thanks to the great help of Kai Uwe Broulik who had give some tips on the past on how to call Java code I started with this same approach:

  • Create a Java file
  • Put the Java code of AccountKit there
  • Call the static function of Java from C++

And… it did work BUT I was unable to get the result, this is because the Java code starts a new Activity and returns the result on a method that must be implemented on the code that Qt creates for starting your activity, so this means I’d need to change the XML manifest to call my subclass instead of what Qt provides, and would need to do a bunch of other stuff myself, basically would get more maintainance work to do.

So another option would be to do all of this from C++, which Kai said it would be better at first, but doing a bunch of JNI scared me a bit, also I hadn’t found the reference page to their API (which he found after the work was done lol). There’s a tool called javap that can dump the Java signature of what is inside the package you got, so with the help of this we went on porting all the calls to AccountKit API to C++/Qt, this way we can call QtAndroid::startActivity() passing a pointer to a class that will handle the result of the new Activity, all in C++ �� .

There were some initial issues with the Enums used (aparently some new Java7 stuff), but the code now doesn’t require a single line of Java code, which is great when integrating in Qt Android Apps.

The result is on GitHub, so if you need this just copy the integration class, it has IFDEFs so if you are testing on !Android it will compile fine. (You still need to follow the Gradle and manifest integration that’s on their dev site), feel free to make PR for fixes and features ��

https://github.com/ceciletti/third-party-qt-utils

As a follow-up to my previous post, I've finally succeeded in building Imaginario as an AppImage package.

I've smoke tested the package in Ubuntu Xenial and Trusty, and while it appears to be working, I'd be happy if someone else could also download and test it in their machines and let me know how it goes. Just please keep in mind that this a very beta release and, while I'm not aware of any major bugs that could corrupt your photos, I wouldn't recommend you to import your photo archive into it, unless you backup it first.
Also, the application needs quite some more polishing before being ready to be publicly advertised to non developers (I'm also considering finding a new icon for it), so the next step after getting a nicely working AppImage will be cleaning up the user interface and make sure that all the (few) features work as advertised. And making a Windows version. And a MacOS one. Oh, I'd better stop thinking about it, or I'll start crying.

I totally missed that last week marked the one-year anniversary of my documentation and guidance of KDE’s Usability & Productivity initiative. I think we’ve achieved a lot over the course of that year!

Note that this is NOT an exhaustive log of everything that happened this week in the entire KDE community, or even in all of Plasma. The actual number of commits and improvements is always vast and enormous–too much to comprehend, really. The KDE Community is staggeringly productive.

Rather, this is always a curated list of only the user-facing improvements I believe are directly relevant to the Usability & Productivity initiative. And speaking of it, this week we got an interesting assortment of new features, bugfixes, and UI improvements–many of which I didn’t mention but will ultimately be appreciated when taken together. Check it out:

New Features

Bugfixes & Performance Improvements

User Interface Improvements

Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal. Also consider making a donation to the KDE e.V. foundation.

January 12, 2019

The first release of Nanonote, my minimalist note-taking app, was a bit rushed: I broke indentation shortly before tagging version 1.0.0... meh.

So here is version 1.0.1. It fixes the indentation and adds the ability to indent or unindent whole lines with Tab and Shift+Tab, in addition to the existing Ctrl+I and Ctrl+U shortcuts.

In addition to these changes, the build system can now generate Debian and RPM packages, making the application easier to install.

These packages are generated by CPack inside an Ubuntu 18.04 Docker. This means they work on my machine, but do not have the same level of quality as packages crafted by real packagers. I am especially looking for feedback regarding the RPM packages, which I haven't tested.

You can find them on the project release page.

There aren't any other end-user changes in this release but I worked on infrastructure a bit: I added unit tests and set up Travis CI for continuous integration. I am probably going to write an article about this next. In the mean time, enjoy Nanonote 1.0.1!

TL;DR; Get your tickets from here!

For the fourth year running, foss-north is taking place. Now bigger than ever.

It all started as a one day conference in a room with too much people in it. We gathered ten speakers and started something that continues to this day.

110 ten people in a room for 110 people.

Back then we, the three organizers: Jeremiah, Mikael and myself, joked over beers that we should have trainings, conference, community rooms and much more. A moderated FOSDEM was a crude description of what we wanted to build. But this was only us dreaming away.

During the past years we’ve tried different venues. We’ve gone from one day, one track to two days and two tracks. This year we decided to go for it all: four days, trainings, a community day and the conference.

Organizing a conference is to manage a chicken and egg type problem. You need speakers to get sponsors, and you need sponsors to get speakers to the venue. The same applies to the audience – visistors wants speakers, speakers wants visitors. This is why it takes time to establish a conference.

Last year we felt that we reached a tipping point – the call for papers was so full that we had to extend the conference with an additional day. We simply could not pick the right contents for a single day. This means that we feel that the conference part is established. If you want to speak, the call for papers is still open.

That takes us to the next steps. The community day consists of various projects and groups organizing workshops, hackathons, install fests, development sprints and whatnot throughout the city. We find venues (usually conference rooms) and projects and hope that people will come visit the various events. Again, starting from zero projects, zero venues and no real idea how many visitors to expect, we are trying to put this together. At the time of writing, it looks great. We have 7 projects and 5 venues fixed, but we are still looking for both projects and venues. If you want to join in, look at our call for projects.

The same logic applies to the training. Now we have training contents, all we need are visitors. The great thing is that our teachers, Michael Kerrisk and Chris Simmonds, are great to work with and understand our situation. Now we just have to work hard to make sure that we find students for them.

The final piece of the puzzle, which is not always visible to speakers and visitors, is the hunt for sponsors. Venues does not come for free, and we believe in compensating our speakers for their costs, thus we need sponsors. We offer the opportunity to host a booth during the conference days and the chance to meet our audience. We also believe that helping a conference focused on free and open source, is a way to contribute to the free and open source movement. For this we have a network of sponsors that we’ve worked with in the past (thank you all!) but as the conference grows, we need more help. If you want to join in, have a look at our call for sponsors

I’ve written a lot about speakers, sponsors and projects. Now all we need are visitors – lots and lots of visitors. So bring your friends to Gothenburg and join us at foss-north. The early bird tickets are available now. Get yours here!

With the ongoing work on realtime data access in KDE Itinerary we need a way show notifications in case of delays or other trip changes. That’s what KF5Notifications is for, which unfortunately isn’t supported on Android yet. Since an Android specific code path in KDE Itinerary for that would be quite ugly, I did look into adding Android support for KF5Notifications. How hard can it be? ;)

KF5Notifications on Android KF5Notifications on Android

C++/Java Integration

How to do notifications with the official Android Java API is widely documented, and also matches the model of KF5Notifications well enough. This would however be the first KF5 framework using Android Java API for its backend, so I’ll focus on these integration bits here.

On the code level this means we need to be able to call Java code from C++ (to trigger a notification), and vice versa (to handle user interaction with the notification), and we need to be able to pass data back and forth.

The mechanism for this is the Java Native Interface (JNI), of which Qt abstract some parts via QAndroidJniObject. Qt itself contains a number of examples on how to use this, and you can look at the KF5Notifications code in D17851. The JNI signature syntax takes a bit of getting used too due to its built-in traps (like a different way of writing fully qualified class names compared to Java code), but at least you usually get helpful debug output at runtime in case of a mistake.

Building and Deployment

The build system integration turned out to be the most challenging part, as the framework consists of a Java part and a native part now. The general idea is that the framework builds and installs a Java library next to the native library, and provides a meta data file that tells androiddeployqt to also integrate the Java part when linking against the native part.

This is done in several Qt modules, but using qmake rather than CMake. Also, Qt only does this for Java code using the official Android Java API, not for using the Android support libraries, which is needed in case of notifications to simultaneously provide compatibility with older Android versions and to comply with requirements of very recent Android versions or the Google Play Store.

Building JARs

The first attempt was following closely what Qt does, and just implement that with CMake. You’ll find the code in D17851. There’s already basic Java support in CMake that makes this pretty straightforward, it essentially just builds a JAR library from a given set of Java source files using the Java compiler directly.

This approach works as long as you just use the basic Android API and don’t need any dependency outside of the normal Android SDK. But as that’s not enough for notifications, we needed another way.

Building AARs

The Android support library (and presumably other higher-level dependencies) break this approach in two places:

  • The canonical way of accessing dependencies on Android is via Maven repositories. Neither CMakre nor the raw Java compiler support that easily.
  • Those libraries are not regular Java libraries (JAR files) but Android libraries (AAR files). That’s essentially a ZIP file bundling the JAR file as well as resources, manifest elements, and other things you might find in an Android APK. However, this is also not directly supported by the Java compiler.

In order to consume AAR files we use the default Android way, building with Gradle (which is also what androiddeployqt does when building APKs). Obtaining and running Gradle is hidden behind a small CMake macro for easy integration, but how to build the Java side is now specified in a build.gradle file rather than in CMake files. This means all Android development related tools and resources become applicable for us. Besides the automatic dependency handling and inbound and outbound support for AAR libraries also things like using Kotlin should be possible. This approach has been implemented in D17986.

Consuming the result in the application is almost identical to the JAR case, we only needed a minor tweak in the androiddeployqt template for this.

Conclusion

Starting with KF5 5.55 we will have basic support for notifications, notification interaction and notification actions on Android. There’s probably still a number of features and flags in KF5Notifications that can be better mapped to Android’s native system, and there’s still work to be done to improve compatibility with a wider range of Android versions, but it’s a good start. But maybe even more importantly, we now have a template for integrating Android Java code in KF5 frameworks.

January 11, 2019

The Qt Company has been running benchmarks like QMLBench for a long time that assist us knowing when a change creates a performance regression, but it’s also important to see how Qt performs at a higher level, allowing components to interact in ways that granular tests like QMLBench can’t show. In this blog post, we’ll walk through new application startup testing results from a more real-world QML benchmark application.

 

The benchmark

For these tests, a relatively simple QML application was developed that utilizes many areas of QtDeclarative and QtGraphicalEffects. The application code was written as a casual developer might, and has not been designed for optimal startup, memory consumption, or performance. Because we’re benchmarking, the application does not make use of Interactive elements or user input. The application is of low complexity, without divergent logic, so that results are as consistent as possible between test runs. Though no benchmark will ever truly simulate real-world performance with user interaction, the test discussed here aims to more accurately represent a real-world QML workload than QMLBench or the QtQuickControls “Gallery” example.

QML Benchmark

The benchmark application. It combines textures, animations, QML shapes, repeaters, complex text, particle effects, and GL shaders to simulate a heavier, more real-world application than other QML benchmarks like QMLBench.

Download the benchmark source code here.

Lars has previously written about The Qt Company’s commitment to improving the performance of Qt, and with the recent release of Qt 5.12 LTS, the efforts made are really showing, especially on QML. Among the improvements, a good number have been towards improving startup performance. Out of the platforms tested, the greatest startup performance improvement was seen on the lowest power device we tested, a Toradex Apalis i.MX6. Let’s explore that.

Startup Performance

overview-chart

The chart above shows how the features in Qt 5.12 LTS really cut down on the startup performance, dropping time-to-first-frame from 5912ms in Qt 5.6 to only 1258ms in Qt 5.12.0, a 79% reduction! This is thanks to a number of new features that can be stacked to improve startup performance. Let’s walk through each.

  1. The Shader Cache – Introduced in Qt 5.9 LTS

    The shader cache saves compiled OpenGL shaders to disk where possible to avoid recompiling GL shaders on each execution.

    Pros: Lowers startup time and avoids application lag when a new shader is encountered if the shader is already in the cache.
    Cons: Systems with small storage can occasionally clear shader caches. If your application uses very complex shaders and runs on a low-power device where compiling the shader may produce undesirable startup times, it may be recommended to use pre-compiled shaders to avoid caching issues. There is no performance difference between cached shaders and pre-compiled shaders.
    Difficulty to adopt: None! This process is automatic and does not need to be manually implemented.

  2. Compiled QML

    Without use of the Qt Quick Compiler detailed below, QML applications built on Qt versions prior to 5.9 LTS would always be compiled at runtime on each and every run of the application. Depending on the application’s size and host’s processing capabilities, this action could lead to undesirably long load times. Two advancements in Qt now make it possible to greatly speed up the startup of complex QML applications. Both of which provide the same startup performance boost. They are:

    Qt Quick Cache – Introduced in Qt 5.9 LTS

    The Qt Quick Cache saves runtime-compiled QML to disk in a temporary location so that after the first run when qml gets compiled, it can be directly loaded on subsequent executions instead of running costly compiles every time.

    Pros: Can greatly speed up complex applications with many qml files
    Cons: If your device has a very small storage device, the operating system may clear caches automatically, leading to occasional unexpected long startup times.
    Difficulty to adopt: None! This process is automatic and does not need to be manually implemented.

    Pre-generated QML (Qt Quick Compiler) – Introduced in Qt 5.3 for commercial licensees, both commercial and open source in Qt 5.11

    The Quick Compiler allows a QML application to be packaged and shipped with pre-compiled QML. Initially available under commercial license from Qt 5.3 onwards, it is available for both commercial and open-source users from Qt 5.11 onwards.

    Pros: Using Quick Compiler has the advantage of not needing to rely on the runtime generated QML cache, so you never need to worry about a suddenly unexpected long startup time after a given application host clears its temporary files.
    Cons: None!
    Difficulty to adopt: Low. See the linked documentation. It’s often as simple as adding “qtquickcompiler” to CONFIG in your project’s .pro file!

  3. Distance Fields – Introduced in Qt 5.12 LTS

    Though Qt has been using Distance Fields in font rendering for a long time in order to have cleaner, crisper, animatable fonts, Qt 5.12 introduces a method for pre-computing the distance fields. Learn more about Distance Fields and implementation in this blog post by Eskil.

    Pros: Using pre-generated Distance Field fonts can drastically reduce start-up performance when using complex fonts like decorative Latin fonts, Chinese, Japanese, or Sanskrit. If your application uses a lot of text, multiple fonts, or complex fonts, pre-generating your distance fields can knock off a huge chunk of time to startup.
    Cons: Generated distance field font files will be marginally larger on disk than standard fonts. This can be optimized by selecting only the glyphs that will appear in your application when using the Distance Field Generator tool. Non-selected glyphs will be calculated as-needed at runtime.
    Difficulty to adopt: Low. See the linked documentation. No additional code is necessary, and generating the distance fields for you font takes seconds.

  4. Compressed textures – Introduced in Qt 5.11

    Providing OpenGL with compressed textures, ready to be uploaded to video memory right out of the gate, saves Qt from need to prepare other file types (jpg, png, etc…) for upload.

    Pros: Using compressed textures provides a faster startup time, decrease in memory usage. It may even provide a bit of performance boost depending on how heavy your texture use is, and how strong of compression you choose to utilize.
    Cons: While the compression algorithms in use for textures inherently require some tradeoff in visual fidelity, all but the most extreme compression schemes will usually not suffer any visible fidelity loss. Choosing the right compression scheme for your application’s use case is an important consideration.
    Difficult to adopt: Low +. See this blog post by Eirik for implementation details. Almost no coding is required, needing only to change texture file extensions in your qt code. Easy-to-use tools for texture compression are available, like the “texture-compressor” package for Node.

 

Conclusions

The i.MX6 is a great representation of mid-tier embedded hardware, and the performance improvements included in Qt 5.12 LTS really shine in this realm. Stack all the improvements together and you can really cut down on the startup time required in low power devices.

With these latest test results for low-power hardware, Qt 5.12 could lend a hand to your development by greatly decreasing startup times, particularly when running on low and mid-tier embedded devices. These new performance improvements are easy to adopt, requiring only the most minor of changes to your codebase, so there’s very little reason to not start using Qt 5.12 right away, especially if your project is cramming heavy QML applications into a fingernail sized SoC. The chart below is a reminder of what’s possible with Qt 5.12 LTS, and faster start-up time makes happier customers.

chart-2

The post Qt 5.12 LTS – The road to faster QML application startup appeared first on Qt Blog.

A bit more than a year ago, the KDE community decided to focus on a few goals. One of those goals (the most important one as far as I’m concerned) is to increase the users’ control over their private data.

KDE developers and users have always been a privacy-minded bunch. But due to all the fun things that have happened in the recent years, we had to switch to the next gear.

We have seen new projects like KDE Itinerary (by Volker), Plasma Vault (by yours truly), Plasma Mycroft (by Yuri and Aditya), etc. There has also been a lot of work to improve our existing projects like KMail.

Now, this post is not about any of these.

It is about a KDE Privacy developer sprint organized by Sando Knauß.

The sprint will be held in Leipzig (Germany) from 22. 3. to 26. 3. and all privacy-minded contributors are invited to join.

LeipzigLeipzig

You can support my work on , or you can get my book Functional Programming in C++ at if you're into that sort of thing.

January 10, 2019

As of a few minutes ago, i merged the code from Chinmoy Ranjan Pradhan's GSOC to support showing PDF Signatures and Certificates in Okular.



Signature handling is a big step for us, but it's also very complex, so i expect it to have bugs and things that can be improved so testers more than welcome.

Compiling is a bit "hard" since it requires poppler 0.73 that was released a few days ago.

But thanks to flatpak, there's no need to compile it, you can run the KDE Okular Nightly on your system to try it

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak remote-add --if-not-exists kdeapps --from https://distribute.kde.org/kdeapps.flatpakrepo
flatpak install kdeapps org.kde.okular

Note: if you have okular installed from another flatpak repo (for example flathub) this will switch you to the KDE Nightlies, you may want to switch back after testing.

And then you can try the adobe sample pdf
flatpak run --share=network org.kde.okular https://blogs.adobe.com/security/SampleSignedPDFDocument.pdf

And you should get stuff like this

It’s the second week of 2019 already, which means I’m curious what Nate is going to do with his series This week in usability .. reset the numbering from week 1? That series is a great read, to keep up with all the little things that change in KDE source each week — aside from the release notes.

For the big ticket items of KDE on FreeBSD, you should read this blog instead.

In ports this week (mostly KDE, some unrelated):

  • KDE Plasma has been updated to the latest release, 5.14.5.
  • KDE Applications 18.12.1 were released today, so we’re right on top of them.
  • Marble was fixed for FreeBSD-running-on-Power9.
  • Musescore caught up on 18 months of releases.
  • Phonon updated to 4.10.1, along with its backends.

And in development, Qt WebEngine 5.12 has been prepared in the incongruously-named plasma-5.13 branch in Area51; that does contain all the latest bits described above, as well.

The first dot release of the 18.12 series is out with fixes and usability improvements. The most exiting change is the fix for audio capture when recording from screen or webcam, a handy feature for people doing video tutorials.

You can now import keyframes to your effects and use them in other projects. On the usability front the “Gain” effect is now in the correct “Audio correction” category and theming issues in the AppImage are now fixed. Speaking of AppImage, we now have a fully automated build system ready so devs can focus on coding gain.

Don’t forget to check our nightly refactoring branch version which received many fixes during the holidays and is ready for another round of testing.

18.12.1 fixes

  • Fix empty warning dialog on missing font in project. Commit. Fixes bug #401903
  • Fix bin item description cannot be edited if it contains zone subclips. Commit. Fixes bug #402817
  • Fix screengrab with audio broken. Commit.
  • Move Gain effect to “Audio correction” category. Commit.
  • Ci: enable freebsd build. Commit.
  • QtScript is not used anymore. Commit.
  • Ci: add recipe for gitlab CI. Commit.
  • Fix incorrect color theme correction for AppImages. Commit.
  • Fix color theme lost on AppImage. Commit.
  • Update AppData app version. Commit.
  • Fix bin/melt.exe & libmlt* loading on Windows. Commit.
  • Necessary OpenGL headers are provided by Qt. Commit.
  • Fix keyframes import. Commit.

January 09, 2019

I happen to edit tabular data in LaTeX format quite a bit. Being scientific documents, the table columns are (almost) always left-aligned, even for numbers. That warrants carefully crafted decimal and digit alignment on such columns containing only numbers.

I also happen to edit the text (almost) always in Vim, and just selecting/changing a certain column only is not easily doable (like in a spreadsheet). If there are tens of rows that needs manual digit/decimal align adjustment, it gets even more tedious. There must be another way!

Thankfully, smarter people already figured out better ways (h/t MasteringVim).

With that neat trick, it is much more palatable to look at the tabular data and edit it. Even then, though, it is not possible to search & replace only within a column using Visual Block selection. The Visual Block (^v) sets mark on the column of first row till the column on last row, so any :<','>s/.../.../g would replace any matching text in-between (including any other columns).

To solve that, I’ve figured out another way. It is possible to copy the Visual Block alone and pasting any other content over (though cutting it and pasting would not work as you think). Thus, the plan is:

  • Copy the required column using Visual Block (^v + y)
  • Open a new buffer and paste the copied column there
  • Edit/search & replace to your need in that buffer, so nothing else would be unintentionally changed
  • Select the modified content as Visual Block again, copy/cut it and come back to the main buffer/file
  • Re-select the required column using Visual Block again and paste over
  • Profit!

Here’s a short video of how to do so. I’d love to hear if there are better ways.

Column editing in VimDemo of column editing in Vim

January 08, 2019

Managing issues is part of the daily life of most software projects. Reacting to bug reports, feature requests, pull requests, tracking what's going on and where to put attention, all that is usually handled in the bug or issue tracker of the project's choice.

On GitHub there are the GitHub issues, and they have become quite powerful over time. Just recently GitHub added the capability to show related issues, pin issues to repositories and to move them between repositories.

One important tool to manage issues on GitHub are labels, those nicely colored badges you can add to issues to get a better overview, to filter lists and queries, or to build further automation such as the presentation of good first issues to people new to the project.


If you have a lot of labels it tends to become a bit of effort to manage them well, especially if you want to keep colors consistent and descriptions up to date. It becomes even more effort when you try to do so across different repositories. We have all seen the psychedelic potpourri of colorful labels which tends to happen when you use labels generously.

Last year I saw Mitchell Hashimoto's excellent talk about anything as code at the Open Source Datacenter Conference in Berlin. He showed there how to use Terraform to manage infrastructure as code beyond the typical management of computing infrastructure such as servers or networks. He showed how to use it for more administrative tasks such as managing teams on GitHub.

This is a great approach because it replaces clicking around in a user interface by a more programming-like approach of maintaining configurations, preferably version controlled, and applying the same rules on them as on code. So you can do pull requests, review changes, have the history of what happened in git, run tests and other automation easily, etc.

The GitHub provider for Terraform also handles labels so I thought I would give it a try to manage labels as code. Directly doing this in the Terraform configuration is possible but it's a bit cumbersome and limited in what you can do with the data in this format. So I decided to put the data into a good old YAML file and writing a bit of Python code to deal with it.

The result is beautiful-labels, a small tool to manage GitHub labels from a YAML description via Terraform. It scans your repository for existing labels and their data, creates a YAML description from it, and then provides you the tools to turn it into a Terraform configuration.

Terraform is great in handling the state of things in the cloud, it takes care of operating the API in an effective way, figuring out what needs to be updated, and gives the user control, for example by providing a dry run which tells what would change without applying the changes yet. This is all quite convenient and powerful.

One thing beautiful-labels is supposed to make easy is the management of label colors. In addition to the convenience of managing them in YAML instead of having to use the UI, it also adds the option to generate an overview of the labels as SVG, nicely grouped in categories. This helps in grouping things together using colors and generally can augment documentation about how you intend labels to be used.


The tool is in an early state but it works. I use it to manage the labels in the inqlude repository on GitHub.

You could add another step of automation by letting CI run Terraform on commits to the YAML file. Maybe something to try for the future. As managing labels is not something you usually do on a daily basis, some manual step might also be good enough.

One caveat with labels is that GitHub uses the name of the label as identifier. That usually works great but can be a bit tricky when changing the name of a label. For this case I recommend to do it in the GitHub UI for now.

There are some other approaches how to do this kind of stuff. One of them is labeler which is a nice tool written in Go to manage labels from a YAML description. It directly operates the GitHub API. The advantage is that it's self-contained but it lacks the power of Terraform in terms of state management. Another is Zach Dunn's post "How we organize GitHub issue: A simple styleguide for tagging" which introduces the notion of color-coded categories.

It's wonderful when pieces come together, such as the GitHub API, Terraform, YAML, git, and people writing open source code around that. They result in a way to beautifully manage labels without having to put in too much effort.

If you have feedback or input please don't hesitate to drop me a line. I would be happy if beautiful-labels would be useful for you as well. Let me know how it goes. :-)

Here is a little playlist to show the new activities in GCompris 0.95.

If you missed it, check the release post on gcompris.net.

We have been using various tweaks to make sandboxed Qt apps well integrated into the system. For KDE Plasma integration, we have been allowing access to kdeglobals config file, where we store the most common configuration, like used icon theme, widget style, etc. A similar approach has been used by Gnome, where they need to allow access to DConf, otherwise applications will not be able to read default system configuration. These tweaks have been usually set in the runtimes and applications using these runtimes automatically inherited all the needed permissions during the build. This has some weak spots, because changing permissions in the runtime requires all applications to be rebuild to pick up the changes, or applications not using the runtimes at all had to allow all the access themself and really not everyone knows what everything needs to be enabled.

This will change with upcoming release of xdg-desktop-portal (version 1.2), which will bring new portal to solve this problem (for both Flatpak and Snap). There is new “Settings” portal, allowing apps to request various configuration from the sandbox, without need to have access outside (kdeglobals, dconf). For Gnome configuration, this has been built in directly in xdg-desktop-portal so there is no need for specific backend support. For KDE Plasma configuration, we have our specific code reading kdeglobals config file in xdg-desktop-portal-kde. This support has already been merged and will be part of Plasma 5.15 release in February. To make applications automatically ask for this configuration through the portal, instead of reading kdeglobals/dconf, I added support to both widely used Qt QPA plugins. For applications running under Plasma we have now this implemented in plasma-integration plugin. This support will be also released with Plasma 5.15 in february. For Qt apps running in Gnome, I added this support into QGnomePlatform, which has been released already some time ago and is already available in Flathub.

Hopefully with all of this released soon and more widely used, we can slowly start removing all the hardcoded permissions for both dconf and kdeglobals config file in the runtimes.

I've uploaded to the Docker hub an image that I will be using for building my Qt applications and packaging them into an AppImage file. To which you might be asking: why bother?

The point is that this is a slightly special image: as its Docker tag (trusty-qt512) says, this image ships Qt 5.12 on top of Ubuntu Trusty (yes, that's 14.04!). The reason why I'm using such an obsolete distribution is that I'm striving to get my AppImage package to be as portable as possible: in fact, my early builds of PhotoTeleport were run on a more recent Ubuntu 16.04, but some users complained that they couldn't run it in their own distributions (IIRC, these were Arch Linux and, indeed, Ubuntu 14.04). The problem is that while packages in the AppImage format bundle their own dependencies in the package, some libraries are generally excluded, as bundling them can cause a variety of issues. But that means that if you are building your application in a system which ships newer versions of these libraries than those installed in your users' machines, there's a high risk that your application will be using some newer symbols not present in the older versions — and therefore your application won't run in those machines.

To solve this problem, the recommended approach is to build on the oldest system that you wish to support; and given that I'm mostly familiar with Ubuntu, I chose Trusty as my target. Luckily, the Qt binary installer shipped at qt.io also happens to support Trusty, so I'm all settled. Indeed, Trusty does not ship recent versions of the C++ compiler, but that can be easily solved thanks to a wonderful PPA which ships up to g++-8.
I've also added the latest version of cmake, as it's unlikely that one can live with the very old version that's shipped in Trusty.

The Docker image can be pulled and used in your own machine or set as a baseline in your .gitlab-ci.yml recipe, if you happen to use Gitlab and are interested to generate the AppImage file from there. That's what I'm trying to do for another project of mine, and while I'm not there yet, the goal is getting closer and closer. Those interested in seeing exactly what is going into my Docker image can have a look at its Dockerfile. There are a few issues with this approach, though, and I feel that I should highlight them in order not to raise your expectations too much:

  • You must B.Y.O.D. (Bring Your Own Dependencies)! It's likely that at least some of the libraries used by your project won't exist in Trusty, or will be an older version unsuitable for your needs. That means that your .gitlab-ci.yml will have to be modified to retrieve a newer version of the library and build it prior to building your application. There are good and bad sides to this: the good one is that this encourages you to use the very latest version of the dependency, which otherwise you might not have used by preferring your distro's version; the bad side is that this is extra work for you (and for the Gitlab CI), and that you risk missing some critical security updates if you don't closely follow the upstream development of your dependencies — something that your distribution's maintainers are likely to do for you. Anyway, here's an example of how I've changed Imaginario's CI recipe to build and fetch exiv2 from its upstream site, with caching of the build artifacts.
  • Gitlab CI becomes slower! Compared to my previous builds, each job has become one or two minutes slower. This is mostly due to not using ubuntu:16.04 as a baseline: the standard Ubuntu images are widely popular, so Gitlab is playing smart and caching them. On the other hand, it seems that my custom image is being pulled every time from the Docker hub. :-(

Of course, if you know of a better way to build a portable binary while not renouncing to the benefits of using a newer Linux distributions, you are very welcome to let me know in the comments. :-)

January 06, 2019

This week in Usability & Productivity, the KDE VDG worked very intensively on aesthetics. The Breeze icon theme gained a lot of attention, resulting in many improvements, and we now have a good number of icon designers diligently working through a backlog of issues. More is on the way too, with several enthusiastic new VDG members who combine an eye for design with strong technical abilities. Expect good things to come of this!

New Features

Bugfixes & Performance Improvements

User Interface Improvements

Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal. Also consider making a donation to the KDE e.V. foundation.

January 05, 2019

More than 11 years after sjfonts 2.0.2 was released today I'm announcing sjfonts 2.1

It contains two enhacements contributed by Yuri Chornoivan
* Delphine font now has the Euro sign
* Steve font now has "basic" Cyrillic characters

If by any chance your distribution is packaging them, update!


https://sourceforge.net/projects/sjfonts/files/sjfonts/sjfonts-2.1/

Yes, it's on sourceforge ;)

Em outubro de 2018, Florianópolis foi sede da sexta edição do LaKademy, o sprint latinoamericano do KDE. Esse momento é uma oportunidade para termos em um mesmo lugar vários desenvolvedores do KDE – tanto veteranos quanto novatos – de diferentes projetos para melhorarem os respectivos softwares em que trabalham e também planejar as ações de promoção da comunidade para o subcontinente.

Na parte técnica, eu trabalhei com Cantor, Sprat, e nos sites do KDE Brasil e LaKademy.

Para o Cantor, eu pesquisei algumas novas maneiras de implementar os backends, em especial quanto a utilização de websockets. Essa é uma ideia antiga que tenta encontrar uma abordagem a ser recomendada para implementação desses backends de forma que possam ser utilizados para qualquer linguagem de programação e funcionem em qualquer plataforma. Entretanto, como nas tentativas anteriores, ainda tenho dúvidas se essa é uma maneira interessante e se os objetivos podem ser atingidos por ela. Enfim, é algo que precisa de mais pesquisa.

Sprat é um editor de texto direcionado para a escrita de artigos científicos. O software implementa a metodologia Amadeus para escrita de artigos, e é mais como uma coleção de sentenças comuns que podem ser utilizadas in seções específicas do artigo. Sprat é meu projeto-pet, e espero lançar esse ano além de transformá-lo em um projeto do KDE.

O site do KDE Brasil uma uma antiga versão do Drupal. Eu e Fred pesquisamos alguns plugins para importar o conteúdo desse site para o WordPress, e atualmente estamos estudando como realizar essa tarefa.

Por último, portei o site do LaKademy para Jekyll. Isso é algo que ainda precisa de algum trabalho, e espero lançá-lo o quanto antes.

Na parte social, discutimos algumas atividades para o KDE nesse ano, como voltar a participar do FISL e Latinoware, tentar comparecer a outros eventos na América Latina (DebConf e Cubaconf, estamos olhando pra vocês), organizar o “Café com Qt” (nosso evento distribuído sobre Qt e KDE), feedbacks sobre o gerenciamento do nosso grupo do KDE Brasil no Telegram, nossos novos materiais promocionais para serem produzidos e distribuídos nos eventos daqui, e mais.

Ainda nesse aspecto, também ajudei os novatos no trabalho de revisão de código do KDE e tirando dúvidas sobre Qt.

LaKademy é uma grande oportunidade para encontrar outros desenvolvedores do KDE e trabalharmos juntos para aumentar nossa comunidade. Nos últimos anos, o KDE assumiu um papel de importância na comunidade brasileira, e estamos planejando expandi-la para diferentes países. Esperamos organizar o próximo LaKademy em algum outro país fora do Brasil, e trabalharemos forte para expandir a comunidade no subcontinente.

Foto em grupo do LaKademy 2018

Nos vemos no LaKademy 2019!

Older blog entries


Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.