dimitris.cc

An interactive guitar fretboard for the Linux terminal

2025-06-01T11:30:00+03:00

Interested in Linux TUI applications? Learning how to play guitar? What about the CAGED system?

I suppose that you have already skipped this article.

Otherwise, let me introduce you to Geekar: a guitar learning application for the Linux terminal.

Features

Let's install it.

First, install fluidsynth using the package manager of your Linux distribution.

Then, run:

pipx install geekar

and

geekar

The terminal shows this - or I hope so:

Geekar initial page

It is an empty guitar fretboard.

Let's add some stuff on it. E.g., select the C major scale:

C Major on Geekar

Show the note names of the selected scale:

C Major notes

Or the triad of the fifth degree (G-B-D):

Triad of the 5th degree

Or just the degree numbers of the scale:

Degree numbers

Let's add some colors. Fold the Settings section - just click on Settings and unfold the CAGED section.

Select some -or all- of the patterns of the CAGED system:

CAGED system

Do the same for any key. Or change the scale type. These are the scales supported:

Major
Natural minor
Major pentatonic
Minor pentatonic

Unfold the Play section and play the scale. Geekar suggests the finger that should be used.

Playing the C major

The fretboard is interactive. Click on it and listen to the corresponding pitch.

Technology and others

The application has been written with the textualize framework. Guitar is not the only musical instrument created with textualize. There is also a piano; I have borrowed ideas and even some code from it.

Geekar has been created by human beings for human beings. It is a free and open source project. It contains bugs. Be kind and report them.

Happy practising.

An ordinary day with a Linux mobile device

2024-07-28T15:00:00+03:00

Just an ordinary day with a mobile device running Linux. Not with a communication device, aka a phone. I believe that a phone should offer very reliably just these features:

Calls
SMS
E2E encrypted foss IM
Deep sleep and push notifications (or any alternative for notifications without draining the battery)

As far as I know, there is no such a device, is there?

So, this post is not about using a Linux phone as a daily driver. It is about how I use a Linux mobile device for tasks that do not involve communications.

Device and operating system

Devices based on the Qualcomm MSM8953 Snapdragon chipset have been ported to closed-to-mainline Linux kernel. Thank you postmarketOS community. Most of the features of my old smartphone are available in postmarketOS. I opted for the edge channel to get new features early. In case of any issue, I report it to the maintenance team. For graphical environment, I have chosen SXMO (Sway). Everything I need is accomplished by a hackable shell script.

Tasks

Web radio

First thing every day - OK, after coffee- is to switch on the radio. Just add some streaming addresses to a simple script.

News

Every now and then I try to keep up with what's happening in the world. SXMO offers a nice sfeed-based script to fetch RSS/Atom feeds. But I prefer to get the news in a single long page of headlines followed by a short description. Something like this:

Screenshot of sfeed_news on SXMO

It has been achieved by modifying the original sxmo_rss script.

Feed subscriptions should be added to ~/.config/sxmo/news_sfeedrc. In the same file, the feed content location is also set:

sfeedpath="$HOME/.local/share/sfeed_news"

# list of feeds to fetch:
feeds() {
        # feed <name> <feedurl> [basesiteurl] [encoding]
        feed 'Example 1' 'https://www.example1.com/xml/rss/all.xml'
        feed 'Example 2' 'https://example2.com/rss'
    }

In general, for long reads I follow an ebook-reader-oriented workflow. However, to get the full, readable version of an article, rdrview has been installed and a w3m keymap entry has been added to ~/.w3m/keymap

keymap R COMMAND "READ_SHELL 'rdrview $W3M_URL -H 2> /dev/null 1> /tmp/readable.html' ; LOAD /tmp/readable.html"

Go to a More link, press Enter, then R and you get a readable version of it (or, I hope so).

Podcasts

I listen to podcasts. Sometimes. With a modified version of the sxmo_rss.sh script.

It offers:

Subscriptions as menu entries
For each subscription, a list of entries for each episode
For each episode, three actions:
1. Get more info about the episode
2. Listen
3. Download

Fetch to get the latest list of subscriptions and episodes:

sfeed_podcast initial menu

Find the content you like:

sfeed_podcast subscriptions menu

sfeed_podcast episodes menu

Play or download it:

sfeed_podcast actions menu

Subscriptions and feed content location should be set in ~/.config/sxmo/podcasts_sfeedrc, e.g.:

sfeedpath="$HOME/.local/share/sfeed_podcasts"

# list of feeds to fetch:
feeds() {
    # feed <name> <feedurl> [basesiteurl] [encoding]
    feed "Cory Doctorow" "https://craphound.com/feed/"
    feed "postmarketOS" "https://cast.postmarketos.org/feed.rss" 
    feed "FSFE" "https://fsfe.org/news/podcast.en.rss" 
    feed "How to fix the internet" "https://feeds.eff.org/howtofixtheinternet" 
}

Podcasts are saved in ~/Podcasts. Use the Files script to play downloaded files.

Musical practice

For musical practice I need a metronome and backing tracks.

Some time ago I wrote a simple metronome script based on sox and mpv. It works OK.

simple_metronome beat selection menu

Already downloaded tracks can be directly played using the Files script. To get new ones, this script has been modified, to present video search results in a single html page:

sxmo_invidious_w3m search results

To facilitate direct playing, mpv has been added as external browser in ~/.w3m/config:

extbrowser xdg-openP
extbrowser2 /usr/bin/mpv

alongside with a couple of entries in ~/.w3m/keymap:

keymap m EXTERN_LINK
keymap M EXTERN

If the cursor is on a More link, video can be directly played by pressing "2, m".

Caveats

The volume of the device is very low. On the bright side, bluetooth works perfectly. Well, for bluetooth.

Headphones -the ones with a cable- are haunted by spooky noise when audio play ends. There is a workaround but a pair of bluetooth headphones is a wiser choice.

Conclusion

This setup works very reliably. It does what is expected to do and it does not crash. Great.

Generate EPUB documents from RSS feeds and URLs and take your e-book reader offline

2023-09-10T12:50:00+03:00

I like e-book readers. In a couple of minutes, you can get the books you like and get started with reading them. Or RSS feeds and that random article you have marked as "read-it-later". The reading experience is nice. Thanks to the e-ink technology, eye strain is drastically reduced. You can also set font type, size, line spacing and margins as you wish. Great.

I don't like e-book readers. I trust devices that run maintained, free software. Most e-book devices run on custom, unmaintained Linux kernels. Others, depend on proprietary software. I don't trust e-book reader devices. And their cost is not insignificant. Not great.

So, I took my humble e-book reader offline. It communicates with the external world with an SD card.

And I created a simple terminal utility which I run on a trusted device. It does this:

Mounts an SD card
Fetches RSS feeds
Downloads read-it-later articles
Converts them to e-pub documents
Saves them to the SD card
Unmounts the SD card

Instead of an SD card, it can also save the e-pub documents to a local ~/path/to directory.

The utility can be found on Codeberg. It is written in Python, it makes use of Calibre for the RSS part and python-readability for the articles.

RSS feeds should be created as Calibre recipes. The configuration of the recipes can be found at ~/.config/calibre/custom_recipes or, if Calibre has been installed as flatpak, at ~/.var/app/com.calibre_ebook.calibre/config/calibre/custom_recipes.

The read-it-later links should be added to a plain text file, e.g. ~/Documents/read-it-later.txt, like this:

www.example.com/my_article.html
Another article www.example.com/another_article
Yet another [article](www.example.com/yet_another.html)

You are going to need the uuid of your SD card. Run ls -l /dev/disk/by-uuid/. Then, plug the SD card into your computer. Run ls -l /dev/disk/by-uuid/ again. The new line contains the uiid of the SD card.

A couple of directories are need as well: - the directory that the SD card should be mounted to, e.g. /mnt/jane/sd. - the target directory for the e-pub documents. It should be a relative path on the SD card, e.g., newspaper/news.

To install the Python dependencies, run pip install -r requirements.txt. A virtual environment is a good idea.

Finally, run:

python ebook_newspaper.py --recipes_dir ~/.config/calibre/custom_recipes --target_device /dev/disk/by-uuid/7afb-3231 --target_mount_point /mnt/jane/sd --target_dir newspaper/news --read_it_later_urls ~/Documents/read-it-later.txt

or, if you don't need an SD card:

python ebook_newspaper.py --recipes_dir ~/.config/calibre/custom_recipes --home_target_dir ~/Documents/newspaper --read_it_later_urls ~/Documents/read-it-later.txt

If Calibre has been installed as flatpak, add the --flatpak option:

python ebook_newspaper.py --flatpak --recipes_dir ~/.var/app/com.calibre_ebook.calibre/config/calibre/custom_recipes --target_device /dev/disk/by-uuid/7afb-3231 --target_mount_point /mnt/jane/sd --target_dir newspaper/news --read_it_later_urls ~/Documents/read-it-later.txt

To archive the older e-pub documents on each script execution, set the --archive option:

python ebook_newspaper.py --archive --recipes_dir ~/.var/app/com.calibre_ebook.calibre/config/calibre/custom_recipes --target_device /dev/disk/by-uuid/7afb-3231 --target_mount_point /mnt/jane/sd --target_dir newspaper/news --read_it_later_urls ~/Documents/read-it-later.txt

Happy reading.

Glossaico 1.2 is out

2023-03-18T14:30:00+02:00

Glossaico 1.2 has been released. Glossaico is a free software application for language learning based on LibreLingo.

New features

Desktop users can navigate using the keyboard
Practice can be canceled without saving progress
Translation infrastructure has been set up, and the user interface has been translated to Dutch, German, Greek, Italian, Polish, and Ukrainian. Many thanks to mondstern, ewm, Lamdarer, Hiajen, and albano.battistella for their work on translation.

Glossaico translated to Greek

Audio plays automatically on listening challenges

Fixes

An issue that prevented progress from being saved has been resolved
KDE themes can be properly applied

Glossaico running on KDE Plasma with the Breeze Dark theme

Install

A flatpak build of Glossaico is available on flathub. If the software center of your distribution supports flatpak and the flathub repository has been configured, use it to install Glossaico. You can also build it from the source code.

Source code

The release source archives can be found here, signed with this key, with fingerprint D528 D3E4 45FD ED42 5902 FA26 FBCE 495D 1EEB 565E.

Get involved

Glossaico is powered by the work of the LibreLingo community. You can get involved by joining the matrix channel and get started with contributing to the platform or to courses. For Glossaico, please report issues and provide your ideas on the bug tracker of the application, submit pull requests, or contribute to the translation of the application.

Glossaico 1.1 is available

2022-11-14T18:30:00+02:00

Glossaico 1.1 has been released. Glossaico is a free software application for language learning based on LibreLingo.

What's new

Most of the work done for this release is related to code refactoring, testing and maintainability improvements. However, Glossaico users may be interested in a set of changes included in this release.

Content update

Course content and application updates have been decoupled. In specific, as soon as new modules, skills and challenges are available for the existing language courses -or even whole new courses- users can immediately install them, without a new Glossaico release to be needed.

Less courses, more courses

Although on the previous version of Glossaico three language courses were offered (Spanish, German and Basque for English speakers), with this release just the Spanish from English course is shown by default. That's because this course is the only ready-for-users one according to the LibreLingo community. Nevertheless, Glossaico users can opt to practice courses that are not 100% ready yet, by navigating to the Configure page and enabling the Show courses in beta phase option. Rough edges and bugs should be expected for these courses, feel free to report any issues found.

Available courses, beta ones included

Practicing and progress

The practice session flow -which challenges are offered, the way they are ordered, repetition intervals, etc- has been updated and now it is closer to the LibreLingo web application. The same applies for the calculation of the practice progress.

User interface and performance

Several user interface changes and performance improvements have also been included in Glossaico 1.1:

Language courses load faster, thanks to improvements in LibreLingo packages as well as to work on Glossaico
Cleaner and simpler user interface
Skill introduction pages are shown, when available:

Spanish introduction page

Install

A flatpak build of Glossaico is available on flathub. If the software center of your distribution supports flatpak and the flathub repository has been configured, just use it to install Glossaico. You can also build it from the source code.

Source code

The release source archives can be found here, signed with the key related to my email address, with fingerprint D528 D3E4 45FD ED42 5902 FA26 FBCE 495D 1EEB 565E.

Get involved

Linux applications with Python and QML

2022-02-26T13:00:00+02:00

Linux applications with QML and Python? Why not? Python is a popular programming language. QML offers an intuitive way to create user interfaces. Kirigami provides useful UI components and implements UI/UX patterns for mobile and desktop. Let's fit these technologies together and create a simple application.

Prerequisites

Obviously, we need Python. Most Linux distributions provide a recent Python. In the rare case that you have to install it by yourself, you may find here some tips. For QML and Kirigami, check the Kirigami introduction guide.

Between Python and QML there is Qt for Python. It offers Python bindings for Qt, and it consists of:

PySide2, so that you can use Qt5 APIs in Python
Shiboken2, a binding generator tool which exposes C++ to Python

On Ubuntu and the like, python3-pyside2.qtcore, python3-pyside2.qtqml and python3-pyside2.qtwidgets are enough for the code of this article. Different distributions may package or name the various bindings differently. E.g., on postmarketOS, everything we need is found in the py3-pyside2 package.

Development

Let's create a simple program to see these technologies in action: a markdown viewer. The UI will be created in QML and the logic in Python. Users will write some markdown text, press a button, and the formatted text will be shown.

Nothing fancy.

It is recommended to use a virtual environment. The venv module provides support for virtual environments with their own site directories, optionally isolated from system site directories. On Ubuntu flavors and derivatives, it is provided by the python3.8-venv package.

Create a directory and a virtual environment for the project:

mkdir simple-md-viewer-project
cd simple-md-viewer-project
python3 -m venv --system-site-packages env/

Activate it using the activate script:

source env/bin/activate

We can verify that we are working in a virtual environment by checking the VIRTUAL_ENV environment variable.

It's time to write some code. A PySide2/QML application consists, at least, of two files: a file with the QML description of the user interface, and a Python file that loads the QML file.

Create a new simplemdviewer directory into simple-md-viewer-project, and add a new simplemdviewer_app.py file in this directory:

import os
from PySide2.QtGui import QGuiApplication
from PySide2.QtCore import QUrl
from PySide2.QtQml import QQmlApplicationEngine, qmlRegisterType

def main():
    """Initializes and manages the application execution"""
    app = QGuiApplication()
    engine = QQmlApplicationEngine()

    base_path = os.path.abspath(os.path.dirname(__file__))
    url = QUrl(f'file://{base_path}/qml/main.qml')
    engine.load(url)

    if len(engine.rootObjects()) == 0:
        quit()

    app.exec_()

if __name__ == "__main__":
    main()

simplemdviewer_app.py

We have just created a QGuiApplication object that, among others, initializes the application and contains the main event loop. The QQmlApplicationEngine object loads the QML main.qml file.

Create a new qml directory in the simplemdviewer one and add a new main.qml file that specifies the UI of the application:

import QtQuick 2.12
import QtQuick.Controls 2.12 as Controls
import org.kde.kirigami 2.12 as Kirigami
import QtQuick.Layouts 1.12

Kirigami.ApplicationWindow {
    id: root

    title: qsTr("Simple markdown viewer")

    minimumWidth: Kirigami.Units.gridUnit * 20
    minimumHeight: Kirigami.Units.gridUnit * 20

    pageStack.initialPage: initPage

    Component {
        id: initPage

        Kirigami.Page {
            title: qsTr("Markdown Viewer")

            ColumnLayout {
                anchors {
                    top: parent.top
                    left: parent.left
                    right: parent.right
                }
                Controls.TextArea {
                    id: sourceArea

                    placeholderText: qsTr("Write here some markdown code")
                    wrapMode: Text.WrapAnywhere
                    Layout.fillWidth: true
                    Layout.minimumHeight: Kirigami.Units.gridUnit * 5 
                }

                RowLayout {
                    Layout.fillWidth: true

                    Controls.Button {
                        text: qsTr("Format")

                        onClicked: formattedText.text = sourceArea.text
                    }

                    Controls.Button {
                        text: qsTr("Clear")

                        onClicked: {
                            sourceArea.text = ""
                            formattedText.text = ""
                        }
                    }
                } 

                Text {
                    id: formattedText

                    textFormat: Text.RichText
                    wrapMode: Text.WordWrap
                    text: sourceArea.text

                    Layout.fillWidth: true
                    Layout.minimumHeight: Kirigami.Units.gridUnit * 5
                }
            }
        }
    }
}

main.qml

We have just created a new QML-Kirigami-Python application.

Cool.

Run it:

python3 simplemdviewer_app.py

It shows a page split into two sections. On the top one you write some markdown code. Upon clicking on Format, the formated text will be displayed on the bottom of the page.

A simple Python QML application

At the moment we have not used any Python interesting stuff. In reality, the application can also run as a standalone QML one:

qmlscene qml/main.qml

It does not format anything; if we click on Format it just spits the unformatted text into a text element.

Nothing special

OK, let's add some Python logic: a simple markdown converter in a Python, QObject derivative class.

Create a new md_converter.py file in the simplemdviewer directory:

from markdown import markdown
from PySide2.QtCore import QObject, Signal, Slot, Property

class MdConverter(QObject):
    """A simple markdown converter"""

    def __init__(self):
        QObject.__init__(self)

        self._source_text = ''

    def readSourceText(self):
        return self._source_text

    def setSourceText(self, val):
        self._source_text = val
        self.sourceTextChanged.emit()

    @Signal
    def sourceTextChanged(self):
        pass

    @Slot(result=str)
    def mdFormat(self):
        return markdown(self._source_text)

    sourceText = Property(str, readSourceText, setSourceText, notify=sourceTextChanged)

md_converter.py

The MdConverter class contains the source_text member variable. The sourceText property exposes source_text to the QML system through the readSouceText getter and the setSourceText setter functions. When setting the sourceText, the sourceTextChanged signal is emitted to let QML know that the property has changed. The mdFormat function returns the markdown formatted text and it has been declared as Slot so as to be invokable by the QML code.

The markdown Python package takes care of formatting. Let's install it in our virtual environment.

Execute:

pip install markdown

It is time to register the new MdConverter type.

Update the simplemdviewer_app.py file to:

import os
from PySide2.QtGui import QGuiApplication
from PySide2.QtCore import QUrl
from PySide2.QtQml import QQmlApplicationEngine, qmlRegisterType
from md_converter import MdConverter

def main():
    """Initializes and manages the application execution"""
    app = QGuiApplication()
    engine = QQmlApplicationEngine()

    qmlRegisterType(MdConverter, 'org.mydomain.simplemdviewer',
                    1, 0, 'MdConverter')

    base_path = os.path.abspath(os.path.dirname(__file__))
    url = QUrl(f'file://{base_path}/qml/main.qml')
    engine.load(url)

    if len(engine.rootObjects()) == 0:
        quit()

    app.exec_()

if __name__ == "__main__":
    main()

simplemdviewer_app.py

The qmlRegisterType function has registered the MdCoverter type in the QML system, in the library org.mydomain.simplemdviewer, version 1.0.

Change the qml/main.qml file to:

import QtQuick 2.12
import QtQuick.Controls 2.12 as Controls
import org.kde.kirigami 2.12 as Kirigami
import QtQuick.Layouts 1.12
import org.mydomain.simplemdviewer 1.0

Kirigami.ApplicationWindow {
    id: root

    title: qsTr("Simple markdown viewer")

    minimumWidth: Kirigami.Units.gridUnit * 20
    minimumHeight: Kirigami.Units.gridUnit * 20

    pageStack.initialPage: initPage

    Component {
        id: initPage

        Kirigami.Page {
            title: qsTr("Markdown Viewer")

            MdConverter {
                id: mdconverter

                sourceText: sourceArea.text
            }

            ColumnLayout {
                anchors {
                    top: parent.top
                    left: parent.left
                    right: parent.right
                }
                Controls.TextArea {
                    id: sourceArea

                    placeholderText: qsTr("Write here some markdown code")
                    wrapMode: Text.WrapAnywhere
                    Layout.fillWidth: true
                    Layout.minimumHeight: Kirigami.Units.gridUnit * 5 
                }

                RowLayout {
                    Layout.fillWidth: true

                    Controls.Button {
                        text: qsTr("Format")

                        onClicked: formattedText.text = mdconverter.mdFormat()
                    }

                    Controls.Button {
                        text: qsTr("Clear")

                        onClicked: {
                            sourceArea.text = ""
                            formattedText.text = ""
                        }
                    }
                } 

                Text {
                    id: formattedText

                    textFormat: Text.RichText
                    wrapMode: Text.WordWrap

                    Layout.fillWidth: true
                    Layout.minimumHeight: Kirigami.Units.gridUnit * 5
                }
            }
        }
    }
}

main.qml

The updated QML code: 1. imports the org.mydomain.simplemdviewer library 2. creates an MdConverter object 3. updates the onClicked signal handler of the Format button to call the mdFormat function of the converter object

Change directory to simplemdviewer and execute:

python3 simplemdviewer_app.py

Play with adding some markdown text: Simple Markdown viewer in action

Hooray.

Package the application

To distribute the application to the users we have to package it. We are going to use the setuptools library.

Create an empty __init__.py file in the simplemdviewer directory.

This file is required to import a directory as a package. The project structure should look like this:

simple-md-viewer-project/
├── env
└── simplemdviewer
    ├── __init__.py
    ├── md_converter.py
    ├── qml
    │   └── main.qml
    └── simplemdviewer_app.py

Create a pyproject.toml file in the simple-md-viewer-project directory, to tell build tools what is needed to build our project:

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

pyproject.toml

Time to add the configuration file for setuptools.

Create a setup.py into the simple-md-viewer-project directory:

from setuptools import setup
setup()

setup.py

Add a new setup.cfg file into the simple-md-viewer-project directory:

[metadata]
name = org.mydomain.simplemdviewer
version = 0.1
url = https://mydomain.org/simplemdviewer
author= Example Author
author_email = example@author.org
maintainer = Example Author
maintainer_email = example@author.org
description = A simple markdown viewer
long_description = file: README.md
long_description_content_type = text/markdown
classifiers =
    Development Status :: 5 - Production/Stable
    License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
    Intended Audience :: End Users/Desktop
    Topic :: Utilities
    Programming Language :: Python
    Operating System :: POSIX :: Linux
keywords= viewer converter markdown

[options]
packages = simplemdviewer
include_package_data = True
install_requires =
    requests
    importlib; python_version >= "3.8"
    markdown

setup.cfg

In the metadata section we have provided information about the application. The options section contains the project dependencies and the import package that our distribution package is going to provide. There is a lot of options and classifiers available. For more details on dependencies management in setuptools, check here.

It is good to have a README.md file as well.

Create a README.md file in the simple-md-viewer-project directory:

# Simple Markdown Viewer

A simple markdown viewer created with Kirigami, QML and Python

README.md

Another important piece is the license of our project.

Create a LICENCE.txt file and add the text of the license of our project.

Apart from the Python stuff, we have to add the QML code to the distribution package as well.

Create a MANIFEST.in file in the simple-md-viewer-project directory, and add:

include simplemdviewer/qml/*.qml

MANIFEST.in

Some last pieces and we are ready to build. We are going to add:

the appstream metadata to be used by the software centers
a desktop entry file to add the application to the application launcher
an application icon
Create a new org.mydomain.simplemdviewer.desktop file into the simple-md-viewer-project directory:

[Desktop Entry]
Version=0.1
Type=Application
Name=Simple Markdown Viewer
Name[x-test]=xxSimple Markdown Viewerxx
GenericName=Markdown Viewer
GenericName[x-test]=xxMarkdown Viewerxx
Comment=A simple markdown viewer application
Comment[x-test]=xxA simple markdown viewer applicationxx
Exec=simplemdviewer
Icon=org.mydomain.simplemdviewer
Terminal=false
Categories=Office;
X-KDE-FormFactor=desktop;tablet;handset;

org.mydomain.simplemdviewer.desktop

Add a new org.mydomain.simplemdviewer.metainfo.xml file into the simple-md-viewer-project directory:

<?xml version="1.0" encoding="utf-8"?>
<component type="desktop">
  <id>org.mydomain.simplemdviewer</id>
  <metadata_license>CC0-1.0</metadata_license>
  <project_license>GPL-3.0+</project_license>
  <name>Simple Markdown Viewer</name>
  <summary>A simple markdown viewer application</summary>
  <description>
    <p>Simple Markdown Viewer is a showcase application for QML with Python development</p>
  </description>
  <url type="homepage">https://mydomain.org/simplemdviewer</url>
  <releases>
    <release version="0.1" date="2022-02-25">
      <description>
        <p>First release</p>
      </description>
    </release>
  </releases>
  <provides>
    <binary>simplemdviewer</binary>
  </provides>
</component>

org.mydomain.simplemdviewer.metainfo.xml

For our tutorial the well known markdown icon is OK.

Get the markdown icon and save it as org.mydomain.simplemdviewer.svg into the simple-md-viewer-project directory.

Now we have to let setup.cfg know about the new files. Let's also provide an easy way to open the application from the console by just typing simplemdviewer.

Update the setup.cfg to:

[metadata]
name = org.mydomain.simplemdviewer
version = 0.1
url = https://mydomain.org/simplemdviewer
author= Example Author
author_email = example@author.org
maintainer = Example Author
maintainer_email = example@author.org
description = A simple markdown viewer
long_description = file: README.md
long_description_content_type = text/markdown
classifiers =
    Development Status :: 5 - Production/Stable
    License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
    Intended Audience :: End Users/Desktop
    Topic :: Utilities
    Programming Language :: Python
    Operating System :: POSIX :: Linux
keywords= viewer converter markdown

[options]
packages = simplemdviewer
include_package_data = True
install_requires =
    requests
    importlib; python_version >= "3.8"
    markdown

[options.data_files]
share/applications =
    org.mydomain.simplemdviewer.desktop
share/icons/hicolor/scalable/apps =
    org.mydomain.simplemdviewer.svg
share/metainfo =
     org.mydomain.simplemdviewer.metainfo.xml

[options.entry_points]
console_scripts =
    simplemdviewer = simplemdviewer.simplemdviewer_app:main

setup.cfg (updated)

Last step is to tinker with the way we import modules.

Update the simplemdviewer_app.py file to:

import os
from PySide2.QtGui import QGuiApplication
from PySide2.QtCore import QUrl
from PySide2.QtQml import QQmlApplicationEngine, qmlRegisterType
from simplemdviewer.md_converter import MdConverter

def main():
    """Initializes and manages the application execution"""
    app = QGuiApplication()
    engine = QQmlApplicationEngine()

    qmlRegisterType(MdConverter, 'org.mydomain.simplemdviewer',
                    1, 0, 'MdConverter')

    base_path = os.path.abspath(os.path.dirname(__file__))
    url = QUrl(f'file://{base_path}/qml/main.qml')
    engine.load(url)

    if len(engine.rootObjects()) == 0:
        quit()

    app.exec_()

if __name__ == "__main__":
    main()

simplemdviewer_app.py (updated)

Create a __main__.py file into the simplemdviewer directory:

from . import simplemdviewer_app

simplemdviewer_app.main()

This last step will facilitate the excecution of the package during development.

Execute from inside the simple-md-viewer-project a last check before packaging:

python3 -m simplemdviewer

It's time to generate the distribution package for our import package.

Make sure that the latest version of build is installed:

python3 -m pip install --upgrade build

Execute from inside the simple-md-viewer-project directory:

python3 -m build

As soon as the build completes, two archives will be created in the dist directory:

the org.mydomain.simplemdviewer-0.1.tar.gz source archive
the org.mydomain.simplemdviewer-0.1-py3-none-any.whl built distribution package
Install the package into the virtual environment:

python3 -m pip install dist/org.mydomain.simplemdviewer-0.1.tar.gz

Run:

simplemdviewer

At this point we can tag and release the source code. The Linux distributions will package it and the application will be added to their software repositories.

Well done.

We can also take care of distributing it. Although the PyPI is probably the standard way to distribute a Python package, I believe that Flatpak is more compatible with the Linux applications ecoystem.

Create an org.mydomain.simplemdviewer.json file in the simple-md-viewer-project directory:

{
    "id": "org.mydomain.simplemdviewer",
    "runtime": "org.kde.Platform",
    "runtime-version": "5.15",
    "sdk": "org.kde.Sdk",
    "command": "simplemdviewer",
    "finish-args": [
    "--share=ipc",
    "--socket=fallback-x11",
    "--socket=wayland",
    "--device=dri",
    "--socket=pulseaudio"
    ],
    "modules": [
        "python3-markdown.json",
        {
            "name": "PySide2",
            "buildsystem": "cmake-ninja",
            "builddir": true,
            "config-opts": [
                "-DCMAKE_BUILD_TYPE=Release",
                "-DBUILD_TESTS=OFF"
            ],
            "sources": [
                {
                    "type": "archive",
                    "url": "https://download.qt.io/official_releases/QtForPython/pyside2/PySide2-5.15.2-src/pyside-setup-opensource-src-5.15.2.tar.xz",
                    "sha256": "b306504b0b8037079a8eab772ee774b9e877a2d84bab2dbefbe4fa6f83941418"
                },
                {
                    "type": "shell",
                    "commands": [
                        "mkdir -p /app/include/qt5tmp && cp -R /usr/include/Qt* /app/include/qt5tmp # https://bugreports.qt.io/broswse/PYSIDE-787",
                        "sed -i 's|--include-paths=|--include-paths=/app/include/qt5tmp:|' sources/pyside2/cmake/Macros/PySideModules.cmake"
                    ]
                }
            ]
        },
        {
            "name": "simplemdviewer",
            "buildsystem" : "simple",
            "build-commands" : [
                "python3 setup.py build",
                "python3 setup.py install --prefix=/app --root=/"
            ],
            "sources": [
                {
                    "type": "archive",
                    "path": "dist/org.mydomain.simplemdviewer-0.1.tar.gz"
                }
            ]
        }
    ]
}

org.mydomain.simplemdviewer.json

This file reads that we use the markdown module and the build info is provided by the python3-markdown.json manifest file. We are going to create this manifest using flatpak-pip-generator.

Get the flatpak-pip-generator, save it into the env/bin/ directory, and run:

python3 env/bin/flatpak-pip-generator markdown

Install org.kde.Sdk and org.kde.Platform, version 5.15, from flathub:

flatpak install org.kde.Platform/x86_64/5.15 org.kde.Sdk/x86_64/5.15

Install the flatpak-builder package using the package manager of your distribution and run:

flatpak-builder --verbose --force-clean flatpak-build-dir org.mydomain.simplemdviewer.json

Test the flatpak build:

flatpak-builder --env=QT_QPA_PLATFORM=wayland --run flatpak-build-dir org.mydomain.simplemdviewer.json simplemdviewer

Build the flatpak bundle:

flatpak-builder --install-deps-from=flathub flatpak-build-dir --repo=simplemdviewer-master --force-clean --ccache org.mydomain.simplemdviewer.json 
flatpak build-bundle simplemdviewer-master simplemdviewer.flatpak org.mydomain.simplemdviewer

Now we can either distribute simplemdviewer.flatpak directly to the users, or submit the application to a flatpak repository, e.g., on flathub.

Great.

I suggest that you also consider: - Signing the source archive with a detached signature - Providing copyright and licensing information for each file with reuse

The code of the article can be found here.

If you have found this article interesting, share it with your friends on your favorite social platform. I hope this platform is Mastodon.

Happy hacking.

Glossaico 1.0 release

2021-12-02T10:00:00+02:00

The first stable version of Glossaico has been released.

Glossaico is a language learning application based on LibreLingo, created for mobile devices running Linux. However, you can also execute it on any environment where Python, Qt and Kirigami are available.

Glossaico on Plasma Mobile

This release offers three language courses:

Spanish for English speakers
German for English speakers
Basque for English speakers

Archives and signatures are available here.

Install

Build

To tinker with the code or build the application package directly from source, please install PySide2 and Kirigami using the package manager of your distribution. Then, extract the release archive and execute:

python3 -m build

After building, you will find the distribution files in the dist directory. Then, install the application:

pip install dist/glossaico-1.0.tar.gz

Report bugs

Please report issues and provide your ideas on the bug tracker of the application.

Get involved

The LibreLingo platform and the language courses have been created and are maintained by a friendly community of volunteers. Feel free to join us on matrix and follow us on Mastodon. With regards to Glossaico, I would be glad to review your pull requests on codeberg.

Glossaico 1.0 beta release

2021-11-07T21:00:00+02:00

The first beta release of Glossaico 1.0 is out for early adopters, testers and linux-on-mobile enthusiasts. Glossaico is a language learning application based on LibreLingo, a community-owned language-learning platform.

Glossaico has been created for mobile devices running Linux, but the technology stack it makes use of -Python and Qt- does not prevent it from running on other environments as well.

Glossaico on Plasma Mobile

At the moment, it contains three language courses:

Spanish for English speakers
German for English speakers
Basque for English speakers

Archives and signatures are available here.

Build and install

First, install PySide2 and Kirigami2 using the package manager of your distribution. Then, extract the beta release archive and execute:

python3 -m build

After building, in the dist directory you can find the distribution files. You can now install the application:

pip install dist/glossaico-1.0b0.tar.gz

Feedback

Provide your feedback and report issues on the bug tracker of the project.

Is the medium the message?

2021-05-30T17:30:00+03:00

Amidst the covid19 pandemic, almost all conferences and meetings have been taking place online. Among them, there is a series of events held by free software (foss) communities, social and solidarity economy cooperatives and groups that defend human rights. Throughout this post, I will refer to them as TGFs (the good folks). No doubt, a critical part of an online conference is the bundle of platforms and tools that power the conference - from registration and presentation to interaction and streaming. Just a moment, is it really a critical part?

Looking into the set of tools adopted by many TGFs you may deduce that the medium does not matter. In many cases, proprietary tools and platforms notorious for censoring and abusive moderation have been used. So, the end justify the means, isn't it? People will eventually judge us by the great things we are going to say and do during an event, not by the medium we have chosen, right?

First, the end does not justify the means; this is a slippery slope that in many cases throughout the history of the humankind has led well-intention causes to catastrophic results. But let's avoid dramas and too much of an abstraction.

We have been educated for years to use software and commercial platforms that do not respect our rights; the promotion and marketing power of the companies that create these tools is huge. At the same time, a TGF that adopts such a kind of software legitimizes their use and sends a wrong message to the people. You trust a group and, as a consequence, you may trust the tools that this group uses. Certainly, just a single TGF has not enough power to whitewash an unethical platform but what about a large set of well trusted groups that simultaneously send this "we use it - you trust us - you trust it" message?

The process of de-educating ourselves and working on our digital emancipation is not a simple task; it needs a lot of will, effort and time to spend. In many cases, the "bad" software has been cleverly designed to lock-in us, making the way out a painful process. But if we want to break free, someone has to start by adopting and promoting the use of ethical alternatives. Is it a task that should be assigned to a TGF as part of its next online conference?

Although I am tempted to just say "yes, it is", life is complicated and full of contradictions and compromises. There is slew of factors that we should take into account. The time available to organize an event varies as well as the amount of people involved. The same applies to the technical expertise of the organizers. Some groups may also have financial resources to spend on software tools while others may -or may not- can ask help from tech savvy friends. So, let's assume that a TGF is going to organize an online event, there is also a reasonable amount of time and volunteers available as well as technical expertise -within the groups or friends- or enough money to spend on software tools. Should this TGF use only free software to do the job?

Again, I would avoid to answer "yes, just use foss". Instead, I would examine the unethical tools (if any) that they are about to employ, the way that they are going to use them, the existence of alternative options to conference participants that do not feel comfortable with these tools, and finally, the goal that they are trying to achieve. Let's examine some usual suspects in a real life scenario: a beloved organization that is going to hold an online conference powered by some not-so-beloved tools like Facebook, Zoom and Youtube.

Facebook does not need further introductions. Its business model is based on tracking, analyzing and modeling users' behavior and it has repeatedly suspended or even deleted accounts that talk about things that do not belong in the for-profit agenda of the company. So, dear TGF, don't use it. No, it's not that easy. The huge userbase of Facebook is quite important for many groups to ignore. Although I believe that it does more harm than good, I understand why groups I do respect cannot avoid using it. From their viewpoint, Facebook is a tool to send the message to a large audience.

However, details matter. E.g, what Facebook features will be used? "Facebook Live" for streaming, "Groups" for internal interactions, "Events" for the conference scheduling? All of them? Most importantly, is Facebook going to be the only platform for all these tasks or will we provide alternatives? To put it simply, are we going to exclude people without a Facebook account?

The question of alternatives-or-exclusion also applies to the Youtube case. Fortunately, Youtube streaming can easily- or less easily- be bypassed by tech savvy participants. Nevertheless, the comments is a whole other story. If we let the conference participants to feed the greedy algorithms of Google, while excluding non-Google users or encouraging people to sign up to theses platforms in the name of a "good message", is the message still a good one?

I suppose that behind the imperative of Facebook and Youtube services lies the lust for big numbers. There is a fallacy that Facebook group/event members or Youtube views is the absolute metric to assess a successful community and the events it organizes. Certainly, quantity is important, but it depends on quality and it also affects quality. E.g. 100 twitter -Elon Musk groupie style- followers is as valuable as 20 Mastodon ones -sometimes derogatorily called "our bubble"? More importantly, TGFs do not only influence others but they are also influenced by others. This is not bad at all. We may opt to choose solely the bad mediums because the good ones are full of our friends which have already been loving us, and increasingly adapt ourselves to the particularities of the commercial platforms to spread our clean and pure message. In the end, our old friends may not love us anymore because we have just got rid of the G of our acronym.

There is also the case of Zoom, a word used as a synonym for "video-conference". Zoom is a platform that has lied about using end-to-end encryption and censored meetings of progressive people. Speakers privacy may not seem relevant for a public conference; however, the adoption of Zoom sends a really bad message. How can we care for privacy and free speech while encouraging people to use a platform that does not care for human rights? Ethical alternatives like Jitsi are quite simple for small events. On the other hand, large events like Remote Chaos Experience or FOSDEM have also been powered by free software tools confirming that conferences of thousands of participants are feasible without resorting to commercial platforms.

Free software tools and decentralized platforms are important neither because they make us look nice -if we adopt them- nor because that's the way to make our grumpy digital vegan friends stop complaining. These tools and platforms ensure the very existence of freedom of speech and foster participation and inclusivity. They are based on interoperability protocols, preventing users from being locked-in and, as a result, abused by powerful actors.

We may -or may not- keep on using Facebook and the like to reach out to a larger audience. If we opt to do so, we should treat them the way they deserve: secondary and complementary tools we are "forced" to use because of network effects.

In conclusion, I tend to trust the tech savvy communities, groups and organizations that put effort on de-educating and re-educating by example the digital citizens by opting for ethical platforms. I also tend to trust the non-tech groups that understand the importance of the tools they use, and ask for help. However, the case of Facebook is kind of special. Personally, I understand why trusted groups still use Facebook as an outreach tool, and I still trust them as soon as they also offer alternative means to avoid excluding non-facebook users. In particular, I truly respect the groups that even if they use the unethical, commercial platforms, they do not compromise; they do not adopt "happy facebook personas" to spread the word, and keep on criticizing censorship and the obscure nature of facebook algorithms, even if these actions put themselves in danger of being suspended or blocked.

Kongress 1.0.1 is available

2021-03-09T09:40:00+02:00

The first bug fix release of Kongress, the conference companion application of the KDE community, is now available. Several fixes have been included in this release:

The time displayed on talk notifications has been corrected
Several crash scenarios of kongressac, the alarm checker of kongress, have been addressed
Corner cases of incorrect grouping of talks into conference days have been fixed
No duplicate conference entries are being displayed anymore
Generic, multi-day calendar events are not included in the per-day pages
Translation configuration has been fixed

FOSSASIA 2021 schedule on Plasma Mobile

Installation

Kongress is available in various desktop and mobile Linux distributions. You can also install the flatpak version of Kongress from the software repository of your distribution or directly from flathub. Android users can also try the nightly build from the F-Droid repository of KDE.

Source code

The source code and signatures can be downloaded from download.kde.org.

Feedback

Feel free to provide your feedback and follow the discussion about its development on the matrix channel of Plasma Mobile.

Kongress 1.0 release

2021-01-28T18:50:00+02:00

I am pleased to announce that Kongress 1.0 has been released. Kongress is a conference companion application enabling users to organize their participation in conferences.

The first release of Kongress offers the following features:

The schedule of a collection of free software conferences, displayed in various ways: full, by day, or by category - if the conference is organized in different tracks.
The scheduled time of each talk shown either in the organizer's or local time zone.
Users can maintain a list of favorite talks per conference.
A notification can be displayed before the beginning of a favorite talk. At the moment, notifications are supported only on Plasma 5.20 (or later).

The primary target user-base of Kongress is people attending a conference with a Linux mobile phone. It also works on desktop, leveraging the convergence capabilities of Kirigami.

Kongress on Plasma Mobile

Installation

Kongress is available in various mobile Linux distributions, like Manjaro and postmartketOS. You can also install the flatpak version of Kongress from the software repository of your distribution or directly from flathub. Android users can also try the nightly build from the F-Droid repository of KDE.

Source code

The source code and signatures can be downloaded from download.kde.org.

Feedback

Feel free to provide your feedback and follow the discussion about its development on the matrix channel of Plasma mobile and the gitlab project page of Kongress.

Calindori and online calendars

2020-12-30T16:35:00+02:00

Currently, Calindori works with calendar data provided by files that follow the iCalendar specification, without offering an out-of-the-box way to synchronize your calendars with external sources, e.g. with Nextcloud. However, this will change in the future. In specific, a plan for this feature has been devised. The first step, a plugin interface that will enable Calindori to use calendar data from various data sources is already in progress.

Although Calindori works on Linux mobile, desktop and even Android, it has been created as the calendar of Plasma Mobile. From this point of view, as soon as a personal information management (PIM) system is available on Plasma Mobile, Calindori will make use of it. However, such a system has not been implemented yet. Various ideas have been discussed on the Plasma Mobile sprints and community meetings. Personally, I am in favor of a sustainable, KDE community driven solution that will work well with Plasma desktop as well as taking into account the particularities of the mobile world, e.g. low energy consumption, "deep sleep" support, etc.

Calindori on desktop

That being said, let me describe here an online calendar synchronization approach that has worked well for me. My personal workflow consists of a personal Nextcloud server -where my calendar is hosted- and various devices that make use of the Nextcloud calendar. As I said in the beginning, Calindori uses iCalendar files for calendar data. Thus, I looked for a mechanism that uses iCalendar files and synchronizes them with Nextcloud. During my research for such a solution, I stumbled upon Vdirsyncer.

As the home page of the project reads, Vdirsyncer is a "command-line tool for synchronizing calendars and address books between a variety of servers and the local file system". Let me now describe how I managed to configure it and make it work with Calindori.

Certainly, the first necessary step is to install Vdirsyncer. Luckily, it is available in various Linux repositories. E.g, on Ubuntu you just have to install the vdirsyncer package. Next, according to the project documentation, a configuration file should be created. So, I created this config file in the ~/.config/vdirsyncer directory:

[general]
status_path = "~/.local/share/vdirsyncer/status/"

[pair nc_myusername_caldav]
a = "nc_myusername_caldav_local"
b = "nc_myusername_caldav_remote"
collections = ["from a", "from b"]
metadata = ["color"]
conflict_resolution = "b wins"

[storage nc_myusername_caldav_local]
type = "singlefile"
path = "~/.local/share/vdirsyncer/caldav/myusername/%s.ics"

[storage nc_myusername_caldav_remote]
type = "caldav"
url = "https://mynextcloudhost.xyz/remote.php/dav/calendars/myusername/personal/"
username = "myusername"
password.fetch = ["command", "keyring", "-b", "keyring.backends.kwallet.DBusKeyring", "get", "Nextcloud", "myusername:https://mynextcloudhost.xyz/:0"]

So, in the configuration file, I defined two storages: - nc_myusername_caldav_local, the local iCalendar file that Calindori will "consume" and the - nc_myusername_caldav_remote, the Nextcloud personal calendar.

The pair nc_myusername_caldav section makes Vdirsyncer synchronize the calendar storages bidirectionally. In case of a conflict -an event or task has changed on both sides since the last sync- I opted for the conflict to be resolved in favor of the remote storage.

With regards to authentication to Nextcloud for user myusername, keyring has been used in order to access the kwallet subsystem via D-Bus.

KDE Wallet Nextcloud entry

This approach works perfectly for me since various passwords that I daily use have been stored in the kwallet which is opened just after logging in to my user session. If this approach does not fit your needs, there are various alternatives.

Then, after creating the ~/.local/share/vdirsyncer/caldav/myusername directory and running:

vdirsyncer discover
vdirsyncer sync

an iCalendar file will be created and populated with your Nextcloud tasks and events.

The next step is to synchronize automatically at certain intervals. So, if you - download vdirsyncer.service and vdirsyncer.timer - put them into ~/.local/share/systemd/user - activate and run the timer

systemctl --user enable vdirsyncer.timer
systemctl --user start vdirsyncer.timer

the Nextcloud calendar will be synchronized every 15 minutes.

Finally, we need to let Calindori know about the Nextcloud calendar. The process is straight forward: navigate to Settings > External > Add and add the Vdirsyncer calendar file. From now on, the tasks and events that are created either on Calindori or Nextcloud side are going to be synchronized between each other.

Add an external calendar

Finally, let me clarify that this approach is not the way that Calindori and Plasma Mobile are going to offer online synchronization of calendars in the future. Nevertheless, Vdirsyncer is a nice, simple utility that enable users to use Nextcloud calendars in Calindori at the moment. It has worked pretty well for me, and I think that the Linux-on-mobile community will find it as an interesting solution for calendar synchronization.

Calindori 1.3 has been released

2020-11-21T16:50:00+02:00

Calindori 1.3, the calendar application for mobile and convergent desktop, is now available. In this release, user interface refinements, fixes and under-the-hood changes can be found.

New features and improvements

First, Calindori now makes use of the Solid wake-up features, when running on Plasma 5.20 or later. In specific, since version 5.20, Plasma has been offering a way that enables applications to inform Power Devil to wake them up at a time specified in the future. When this feature is used, applications facilitate the system to save power, by letting the system to be kept in deep sleep.

Calindori on desktop

In addition, in Calindori 1.3, several rough edges have been smoothed out as well as user interface features have been added. For example, in “All Tasks”, you can opt to display or hide the completed tasks, while on desktop, when a high resolution monitor is available, the month page is properly scaled. Moreover, when executing the application on a wide screen, the size of the global drawer has been reduced. This way we let the user focus on the main (calendar) page, without being distracted by the size of the side panel. Furthermore, the positioning of the confirmation dialog prompted when users try to delete an incidence has been fixed. Repeating and multi-day events are now properly displayed in the day and week views.

All tasks on mobile

Finally, support for external calendars has been added. In specific, external calendar files can be "attached" to Calindori and, whenever a file is modified by an external app, that change is shown in Calindori. So, users can now use a calendar that has been created by a different application. For example, if you have set-up calendar file synchronization with vdirsyncer, navigate to Calendar Management > External and add a calendar that’s also used by other devices.

Installation

Calindori is available on KDE Neon for Plasma Mobile, Manjaro and postmartketOS. You can also test the latest build of Calindori by using the flaptpak nightlies kdeapps repository for ARM and x84_64. Users can also build it from source on any Linux distribution. The source code and signatures can be downloaded from download.kde.org.

Feedback

Feel free to provide your feedback and follow the discussion about its development on the matrix channel of Plasma Mobile. Bugs can be reported in the bug tracker of KDE while design and development feedback can be added to gitlab issues.

Calindori 1.2; the official one

2020-09-12T01:00:00+03:00

Calindori 1.2 is out! Although a couple of versions have also been tagged, that's the first stable release of Calindori as a KDE application.

In this release, new ways to manage your schedule have been added, several rough edges have been smoothed out, and a set of mobile-desktop convergence bits have been introduced.

User interface

Now you can review the incidences -events or tasks- of each day in a day view. Incidences are presented in an hour list, ordered by their scheduled start date or end date.

A week view has also been added, offering a per-week dashboard experience. On that dashboard, a list view displays the days of each week alongside with the incidences scheduled on each week day.

Week view on mobile

Improvements

In Calindori 1.2, you can set the start and due date of a task as well as schedule several alarms based on its start date. With regards to events, when a new one is created, a reminder is added by default and the start time is set to the next hour. But, Calindori wouldn't have been a KDE application, if you couldn't opt out or set a custom alarm time in the settings page.

Task editor on mobile

Several issues have also been addressed. For example, when an event or task starts and ends within the same hour, we ensure that it is always displayed. Moreover, the calendar import functionality has been modified in order to function properly on desktop.

Finally, the vertical date swipes mechanism has been substituted with a simpler approach that improves the overall application performance.

Convergence

Apart from the convergence features that come with Kirigami, a set of Calindori specific ones have also been introduced. For example, when executing the application on desktop, the global drawer is always displayed at the left side of the screen, like a panel, while on mobile, it works like a modal drawer - the Plasma Discover way.

In addition, when running Calindori on a device with a wide screen, the incidences of each week or day are displayed in a row, making use of the space available; on mobile devices, they are displayed in a column.

Day view on mobile

Installation

Calindori is available on KDE Neon for Plasma Mobile as well as on postmartketOS. It’s also available in the flaptpak nightlies kdeapps repository for ARM and x84_64. Finally, you can also build it from source on your Linux desktop workstation. The source code and signatures can be downloaded from download.kde.org.

Feedback

Although you can use Calindori as your calendar application on any Linux desktop distribution, it is true that Calindori has been created for the Plasma Mobile ecosystem. So, feel free to provide your feedback and follow the discussions about its development on the matrix channel of Plasma Mobile.

Going to Akademy - with a companion

2020-08-30T14:00:00+03:00

In January, one month before travelling to Brussels for FOSDEM 2020 (do you remember when the conferences were taking place in the non-virtual world?), I was following a conversation on Mastodon. The discussion was about free software companion apps that could be used on the PinePhone in FOSDEM. Calindori, the calendar of Plasma Mobile was mentioned as a tool that could do the job.

The Kongress icon, thanks to Mathis Brüchert

The next day I found myself copying and modifying some Calindori code, adding new things and putting into the app the FOSDEM conference data. So, Kongress was born; a companion application for congresses - virtual or not.

With regard to the functionalities that it offers, Kongress includes: - Checking the conference schedule - Tagging talks as favorites - Management of multiple conferences

Conferences supported by Kongress

From a technical point of view, the user interface of Kongress is based on Kirigami and follows the KDE Human Interface Guidelines while the back-end system uses KCalendarCore. For Kongress to be able to be used in a conference, the schedule should have been released in the ical format.

Personally, I used it in FOSDEM 2020 and it fitted my needs. Since the annual conference of the KDE community, Akademy 2020, has also been added to Kongress, I am going to use it in Akademy 2020 as well. I would be happy if Akademy attendees found it helpful and provided also their feedback.

Akademy 2020 schedule

Kongress can be found in the unstable edition of KDE Neon - so PinePhone users running KDE Neon can download it directly from the Neon repositories. It's also available in the flaptpak nightlies kdeapps repository for ARM as well as x84_64 platforms. Finally, Android users can get it from the F-Droid repository of KDE. Nevertheless, since I usually do not spend my volunteer time on working on Android, that version may need some love; patches welcome.

See you at Akademy 2020!

Creating a serial adapter for PinePhone

2020-05-01T12:00:00+03:00

The other day I wanted to connect to my PinePhone from my desktop computer. Since USB tethering is not functional yet on KDE Neon that runs on the phone, a wifi connection should have been established on the phone side to get access to a terminal. But if you would like to debug the booting process or wifi is not an option, serial communication is the way to go.

PinePhone offers serial connectivity through the headphones connector. In specific, the earphone jack works as expected -as an audio jack- if the 6th hardware switch on the back of the phone is ON. Switch it off, and the audio jack works as a serial adapter; a USB-to-jack serial console cable is also needed.

Unfortunately, ordering such a cable during the covid-19 lock down would mean long delays. Luckily, after asking on the Plasma Mobile matrix channel, Bhushan suggested I create my own converter cable, using an old USB to serial adapter -which I already had- and a spare audio cable. Let's see how to make it.

USB to serial adapter

At first, cut the audio cable. What I found after cutting was a copper wire ground sheath wrapped around two insulated audio signal wires. It is easy to bring out the wires by applying some fire.

Audio cable wires

Next, connect the audio cable wires to the USB serial cable endpoints. In my case, there are four connection points on the USB cable side:

Red +3.3 V
Black GND
White RXD
Green TXD

According to the information found at the pine64 wiki, the cables should be connected like this:

Left audio to TXD
Right audio to RXD
Ground connection

I also used some spare jump wires with solid tips to make the construction more stable, but that's not required. After insulating the connection with some tape, the serial cable is ready to use.

Ready to use cable

So, it's time to test our construction. A friendly utility for serial connection is picocom. Enter:

sudo picocom -b 115200 /dev/ttyUSB0

Then, switch on the PinePhone, and the booting process is shown on the terminal. It's also possible to login to an interactive shell. E.g., open another terminal and type:

sudo bash -c "echo phablet > /dev/ttyUSB0"
sudo bash -c "echo 1234 > /dev/ttyUSB0"

That's all. Happy PinePhone hacking!

This post was originally published in May 2020. On 1 Feb 2022 it has been updated: the voltage of the cable has been changed from 5 to 3.3.

Calindori 1.1 is out: reminders, repeating events and more

2020-02-19T13:00:00+02:00

A new version of Calindori, the calendar application of Plasma Mobile, is now available. In Calindori 1.1, a set of new features has been added as well as the user interface has been improved, following the KDE human interface guidelines.

Event reminders

You can now add reminders to calendar events. To manage event reminders, a separate background application, calindac, has been created. Calindac looks for alarms into the Calindori ical files and triggers alarm notifications. The users may dismiss the alarm displayed or suspend it for a configurable amount of time.

Add reminder

Repeating events

In Calindori 1.1, repeating events can be added. In particular, you can mark an event as repeating on the event editor. An overlay sheet enables you to provide the repeating event details. Then, on the events list view, you can review the repeating information of each event.

Add repeating event

Month view swipes

To facilitate navigation among months, the month shown can be switched via vertical gestures; but you can still change the active month using the buttons on the bottom of the page.

Flat events view

To get an overview of your events, a flat view of all the registered events has been added. The events have been sorted by start date, displaying the upcoming events on the top of the page.

All events page

User interface improvements

The user interface of the event and todo cards has been modified, to make the information displayed more clear. In specific, helper icons have been added as well as page space, which is important on mobile devices, has been saved. Finally, Mathis Brüchert designed a new Calindori icon. Thanks Mathis!

Under the hood

Last but not least, the Calindori code has been streamlined, improving performance and maintenace. Nicolas Fella put a lot of effort into this task.

Installing Calindori

Calindori is available on KDE Neon for Plasma Mobile as well as on postmartketOS. You can also install the flatpak build on any Linux distribution. Finally, the nightly build of Calindori for Android can be found in the F-Droid instance of KDE.

Coming soon

Looking to the future, the most important piece to be added to Calindori is online calendar synchronization. The good news is that there is already work in progress on this.

Meanwhile, if you are interested in getting involved in Plasma Mobile, you can check the Find your way guide and join us on matrix.

Creating a Kirigami application, the easy way

2019-11-11T11:00:00+02:00

Interested in getting started with Kirigami development in a few minutes? Since version 5.63 of the Kirigami framework, there is an easy way to do so: an application template. The template facilitates the creation of a new application, using CMake as the build system, and linking to Kirigami dynamically as a plugin at runtime.

Let's see how it works. As a starting point, we will use a virtual environment running the latest KDE Neon User edition. This is by no means a requirement, any Linux distribution with Kirigami 5.63 or later perfectly fits our needs. KDE Neon has been chosen just because it provides -by design- the latest Qt, KDE frameworks and applications. Moreover, a virtual machine will let us play fearlessly with the system directories.

At first, we install the packages required:

sudo apt install qtbase5-dev build-essential git gcc g++ qtdeclarative5-dev qml-module-qtquick-controls libqt5svg5-dev qtmultimedia5-dev automake cmake qtquickcontrols2-5-dev libkf5config-dev libkf5service-dev libkf5notifications-dev libkf5kiocore5 libkf5kio-dev qml-module-qtwebengine gettext extra-cmake-modules libkf5wallet-dev qtbase5-private-dev qtwebengine5-dev libkf5wallet-dev qt5-default kirigami2-dev kdevelop kapptemplate

We are ready to convert the template to a working application. We will do it in two different ways:

Using the KAppTemplate tool
With KDevelop

The KAppTemplate way

KAppTemplate, the Qt and KDE template generator, consumes templates and generates source code. After launching KAppTemplate, on the second page of the wizard, we select Kirigami Application. The Kirigami template can be found under Qt > Graphical on the leftmost panel. We also provide a project name, e.g. hellokirigami.

Choose your project template

On the last page of the wizard, we set the application directory and, optionally, some details about our application.

Set the project properties

After clicking to Generate, the source code of our application is created; we are ready to start building it.

cd /home/user/src/hellokirigami
mkdir build
cd build
cmake  ..
make -j4
sudo make install

Since the development environment is a virtual one, we are free to install our application in the system directories. Otherwise, in case of working on the host machine, custom install prefixes would be recommended.

Hello Kirigami

Using KDevelop

KDevelop is a full-featured IDE that integrates perfectly with application templates. On the Project menu, after clicking to the New From Template menu item, the application template wizard is shown.

Create a KDevelop project from template

We just select the Qt category on the leftmost panel and Kirigami Application on the right one, and set a project name, e.g. hellokirigami2.

Kirigami template on KDevelop

On the last screen of the template wizard, we may also select a version control system, if needed. Not this time.

Back to KDevelop, we may set a custom installation prefix. Since we are not going to to install anything, we just select Debug as Build type and don't bother with installation prefixes.

Set the build directory

The Projects pane enables us to examine the source code file hierarchy, while on the right we can see the code of each file. To test our application, we Build and, finally, Execute our application. Both actions can be found on the main toolbar.

Build and execute

Having clicked to Execute, on the Launch Configurations dialog, we Add a new configuration, selecting the scr/hellokirigami2 project target.

Set application target on KDevelop

To check how the application will run on Plasma Mobile, we have to configure again a little bit our environment. In particular, on the Run menu, we click to the Configure Launches item. The configuration dialog will be displayed.

Launch configurations on KDevelop

Then, we add the following to Environment:

QT_QUICK_CONTROLS_MOBILE=true
QT_QUICK_CONTROLS_STYLE=Plasma

Set mobile environment variables

We are prompted with the mobile version of our application.

Hello Kirigami

That's all. It's time to add your own code bits. Happy hacking!

Akademy, the pulse of a vibrant community

2019-09-03T08:00:00+03:00

Have you ever wondered how KDE, a global community of volunteers, can successfully create and maintain such a large set of software projects? Projects that, among many others, include image and video editing applications, a powerful desktop environment and frameworks that make the work of developers easier. If you have not found the answer yet, I recommend you to participate in Akademy, the annual conference of the KDE community, because the answer is not a technical one.

The answer is the community spirit. Regardless of nationality, sexual orientation or age, everyone feels comfortable in KDE. If you participate in a BoF session, raise your hand and shoot a question, no matter your technical expertise, every single person will pay attention to what you will say. KDE is an inclusive community; be respectful and tolerate others and you will be more than welcome.

Akademy 2018, Vienna. Photo by Ingride Costa

This year Akademy will take place in Milan, Italy, from the 7th to the 13th of September. If you have the opportunity to be in Milan, don’t miss it. During the first two days, a set of very interesting talks will be given; then, BoFs, meetings and workshops will follow, where you will be able to learn new things and discuss the plans of the community for the years to come. Last but not the least, you will be among the first to know the results of the voting for the goals of the community for the next 2 to 3 years.

During the conference, apart from attending the talks, I am planning to meet my friends from Plasma Mobile and discuss with them the current status as well as the next steps of the mobile platform of KDE. Moreover, on Thursday morning, Camilo -developer of Maui, Vvave and many other interesting projects- and me, will host a 4-hour workshop.

Workshop participants will be introduced to application development with QML, Qt Quick Controls and Kirigami. Target audience is developers without previous experience in QML; we will learn together how to set up the development environment and we will get familiar with the Qt Quick Controls module. Finally, we will find out what the Kirigami toolkit offers us, and we will hack a real Kirigami application. The only requirement is a workstation with the latest KDE Neon user edition, either on host or a virtual machine. I should mention that KDE Neon is not an "official" suggestion by KDE; it has been chosen because it is familiar to us, so we will quickly and easily offer a working development environment. The workshop will start at 9.30 in the morning and Akademy attendees who are willing to get their hands dirty with QML are welcome.

I wish everything to go as planned and to enjoy another Akademy; it is a reviving experience that gives you strength to keep on contributing. It would also be very nice to find some time and get to know the city; the gastronomy guide created by Riccardo looks very promising!

Organizing time on Plasma Mobile

2019-05-31T09:00:00+03:00

About a year ago the phabricator tasks of Plasma Mobile were extensively revamped. We tried to make clear the objective of each task, providing helpful resources and facilitating onboarding. Looking at the features needed to reach the “Plasma Mobile 1.0” milestone, the calendar application was sticking out. So, Calindori was born (even though this name was coined some months later).

Build on top of Qt Quick and Kirigami and following -or trying to follow- the KDE human interface guidelines, the whole point of Calindori is to help users manage their time. Through a clean user interface, it aims to offer the users an intuitive way to accomplish their tasks.

Calindori home and events pages

For the time being, Calindori provides the basic calendar functionalities: you can check previous and future dates and manage events and todos. Tasks and events of different domains (e.g. personal, business) can be included in different calendars, since multiple calendars are supported. Import functionality has also been added so as to make the transition of new users easier.

You may test Calindori at the moment, either building the 1.0 release from source or just installing the flatpak bundle. A Plasma Mobile phone is not a requirement for testing Calindori; it perfectly runs on Plasma or any other Linux desktop environment. It has been designed having in mind the needs of the mobile users, but the great advantage of using a framework like Kirigami is the adaptation of the user interface to desktop environments, with little or without additional development effort. It will also be very helpful to report issues and provide feedback on the gitlab repository.

Behind the scenes, the iCalendar standard is followed, as implemented by the KDE KCalcore library. KDE/Qt Developers may also find interesting the date and time pickers included in the application. These components may be reviewed, enhanced and, why not, find their way to the KDE frameworks.

Calindori date and time pickers

Looking to the future, the support of repeating events and reminders are the first tasks that should be handled. Then, caldav should also be supported, enabling the users to synchronize their online calendars (e.g. Nextcloud). Nevertheless, that’s a task that should be discussed with the rest of the Plasma Mobile team. The next KDE Akademy at Milan in September will be a great opportunity.

The Plasma Mobile team has made a significant progress during the last months, trying hard to offer a KDE Plasma experience to the mobile users. Even though it is not an 100% complete mobile platform, the missing parts are slowly being added to the software stack. But a lot of interesting tasks are still available, waiting for people willing to help the Plasma Mobile ecosystem grow.

In the next months a set of devices -like PinePhone and Librem 5- are expected, enabling the execution of Linux distributions on real mobile hardware. This will change significantly the free software mobile environment; it will open the way for more privacy friendly devices that could put the users in the driver’s seat, without spying on them or treating them like products. I believe it is the perfect time to get involved with projects like Plasma Mobile, helping to create an open mobile platform that will bring a KDE breeze to mobile phones.

Notes on the Plasma Mobile sprint

2019-02-26T18:00:00+02:00

As soon as I offered my mobile phone number for the proof of concept of sending an SMS from a phone running Plasma Mobile, I felt like a student in the Stanford Research Institute expecting the very first message via the ARPANET from UCLA . OK, that’s certainly an exaggeration, but it shows that the sprint, except the technical achievements, it was also full of community spirit and sometimes, emotions.

All these and many more happened in the Plasma Mobile sprint. From the 4th to the 9th of February the Plasma Mobile contributors met in the Endocode offices in Berlin. I was there for the whole week and I enjoyed every single moment.

Sending SMS with Plasma Mobile

But why to bother to get involved with Plasma Mobile? After all, every floss initiative on the mobile field is damned to fail, isn’t it? Even if this was true -which it is not, since every failure gives lessons and future initiatives may base their work on top of it- we really need mobile devices based on free software.

Since the mobile phone already is the primary computational device -at least for content consumption and communications- we deserve devices that respect our digital rights. We need secure devices and platforms that respect our privacy - in reality, not like the funny popups of the websites, full of trackers, telling us that they value our privacy... And for this to happen, mobile users should take back the control of their devices. Relying on closed platforms, like the ones currently on the market, it is the phone that controls us; and this should not be the case.

Why to bother to bring KDE Plasma to mobile phones? Well, the KDE community has already shown that it can offer a full featured desktop workspace and a large ecosystem of applications. It is the desktop environment that I use on my professional and personal workstations and having contributed to KDE for many years I think that Plasma Mobile is the perfect place for me to be.

The sprint was a quite successful event, from a technical as well as from a community viewpoint. We worked on several issues that we had set as priorities before the sprint; high DPI scaling has improved, new features have been added and bugs have been fixed on applications like Angelfish, Kirigami Gallery and Discover (among others) and a new rootfs for devices running on Halium has been published. Also, we configured the telephony infrastructure and we revamped the documentation.

Part of the team - important pieces missing

Most importantly, we strengthened the bonds within and outside the team. Working together, sharing ideas, talking about KDE, technology and many more for a whole week is invaluable for building the foundations of a successful team. At the same time, since we are not creating Plasma Mobile for ourselves or for a bunch of friends, we spent a couple of hours on the sprint topics suggested by the community. Also, the AMA session was a great opportunity for us to get feedback from the community, reflect on what we have done so far, what it is the impact of our work, and what we think about the future.

Looking to the future, it is not easy to make predictions about free software on mobile. On the one hand, there are many external factors -binary blobs, old and customized Linux kernels, the imminent nightmare of Google Fuchsia, to name some of them- that put obstacles on our way. On the other hand, there are communities like Halium and postmarketOS that offer us the opportunity to run Plasma Mobile on various devices; and there is also hardware like PinePhone and Librem 5.

What is certainly true is that the current proprietary mobile environment does not fit many of us. And it also true that working on a free software project for mobile devices is challenging, exciting and by all means it is worth it. Feel free to join us.