users: repair broken tests

Applying the styling tool breaks the string literals.

.clang-format

@@ -8,6 +8,7 @@ AlignEscapedNewlines: DontAlign
 AllowAllParametersOfDeclarationOnNextLine: "false"
 AllowShortFunctionsOnASingleLine: Inline
 AllowShortIfStatementsOnASingleLine: "false"
+AllowShortLambdasOnASingleLine: All
 AllowShortLoopsOnASingleLine: "false"
 AlwaysBreakAfterReturnType: TopLevelDefinitions
 AlwaysBreakTemplateDeclarations: Yes
@@ -27,9 +28,9 @@ PointerAlignment: Left
 ReflowComments: "false"
 SortIncludes: "true"
 SpaceAfterCStyleCast: "false"
+SpaceInEmptyBlock: "false"
 SpacesBeforeTrailingComments: "2"
-# SpaceInEmptyBlock: "true"
 SpacesInAngles: "true"
 SpacesInParentheses: "true"
 SpacesInSquareBrackets: "true"
-Standard: Cpp11
+Standard: c++17

.gersemirc

@@ -0,0 +1,10 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Gersemi configuration
+color: false
+definitions: [ CMakeModules/CalamaresAddTest.cmake ]
+line_length: 120
+quiet: false
+unsafe: false
+

.git-blame-ignore-revs

@@ -0,0 +1,5 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+18fef8dfe5d926ec0bc979562553adf4db8db2e9
+874a0c1f38b0da4e5bc83083b13a63b1c7eed935

.github/workflows/issues.yml

@@ -0,0 +1,18 @@
+name: issues
+
+on:
+  issues:
+    types: [opened, reopened, closed]
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "remove in-progress label"
+        if: github.event.issue.state != 'open'
+        run: |
+          curl -X DELETE \
+            -H 'Accept: application/vnd.github.v3+json' \
+            -H 'Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}' \
+            "https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/labels/hacking%3A%20in-progress"
+

.github/workflows/nightly-debian.yml

@@ -0,0 +1,34 @@
+name: nightly-debian-11
+
+on:
+  schedule:
+    - cron: "12 23 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://debian:11
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare git"
+        shell: bash
+        run: |
+            apt-get update
+            apt-get -y install git-core jq curl
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-debian11.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.github/workflows/nightly-fedora-qt6.yml

@@ -0,0 +1,33 @@
+name: nightly-fedora-qt6
+
+on:
+  schedule:
+    - cron: "52 2 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+    -DWITH_QT6=ON
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://fedora:38
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare git"
+        shell: bash
+        run: yum install -y git-core jq curl
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-fedora-qt6.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.github/workflows/nightly-neon-unstable.yml

@@ -0,0 +1,29 @@
+name: nightly-neon-unstable
+
+on:
+  schedule:
+    - cron: "59 23 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://kdeneon/plasma:unstable
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-neon.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.github/workflows/nightly-neon.yml

@@ -0,0 +1,41 @@
+name: nightly-neon
+
+on:
+  schedule:
+    - cron: "52 23 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://kdeneon/plasma:user
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-neon.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh
+      - name: "Calamares: archive"
+        working-directory: ${{ env.BUILDDIR }}
+        run: |
+          DESTDIR=${{ env.BUILDDIR }}/stage ninja install
+          tar czf calamares.tar.gz stage
+      - name: "Calamares: upload"
+        uses: actions/upload-artifact@v3
+        with:
+          name: calamares-tarball
+          path: ${{ env.BUILDDIR }}/calamares.tar.gz
+          if-no-files-found: error
+          retention-days: 7

.github/workflows/nightly-opensuse-qt6.yml

@@ -0,0 +1,33 @@
+name: nightly-opensuse-qt6
+
+on:
+  schedule:
+    - cron: "32 2 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+    -DWITH_QT6=ON
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://opensuse/tumbleweed
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare git"
+        shell: bash
+        run: zypper --non-interactive in git-core jq curl
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-opensuse-qt6.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.github/workflows/nightly-opensuse.yml

@@ -0,0 +1,32 @@
+name: nightly-opensuse
+
+on:
+  schedule:
+    - cron: "32 23 * * *"
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DCMAKE_BUILD_TYPE=Debug
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://opensuse/tumbleweed
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare git"
+        shell: bash
+        run: zypper --non-interactive in git-core jq curl
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-opensuse.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.github/workflows/push.yml

@@ -0,0 +1,38 @@
+name: ci-push
+
+on:
+  push:
+    branches:
+      - calamares
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+  workflow_dispatch:
+
+env:
+  BUILDDIR: /build
+  SRCDIR: ${{ github.workspace }}
+  CMAKE_ARGS: |
+    -DWEBVIEW_FORCE_WEBKIT=1
+    -DKDE_INSTALL_USE_QT_SYS_PATHS=ON
+    -DWITH_PYTHONQT=OFF
+    -DCMAKE_BUILD_TYPE=Debug
+  GIT_HASH: ${{ github.event.head_commit.id }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: docker://kdeneon/plasma:user
+      options: --tmpfs /build:rw --user 0:0
+    steps:
+      - name: "prepare source"
+        uses: calamares/actions/generic-checkout@v5
+      - name: "install dependencies"
+        shell: bash
+        run: ./ci/deps-neon.sh
+      - name: "build"
+        shell: bash
+        run: ./ci/build.sh

.reuse/dep5

@@ -15,6 +15,10 @@ Files: man/calamares.8
 License: GPL-3.0-or-later
 Copyright: 2017 Jonathan Carter <jcarter@linux.com>
 
+Files: 3rdparty/kdsingleapplication/*
+License: MIT
+Copyright: Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@ kdab.com
+
 ### BUILD ARTIFACTS / NOT SOURCE
 #
 # QRC Files are basically build artifacts
@@ -29,6 +33,11 @@ Files: .github/ISSUE_TEMPLATE/*
 License: CC0-1.0
 Copyright: no
 
+# GitHub actions are not part of the source
+Files: .github/workflows/*.yml
+License: CC0-1.0
+Copyright: no
+
 # Packaging information
 #
 Files: data/FreeBSD/distinfo data/FreeBSD/pkg-descr data/FreeBSD/pkg-plist
@@ -45,6 +54,13 @@ Files: data/example-root/usr/share/zoneinfo/Zulu data/example-root/usr/share/zon
 License: CC0-1.0
 Copyright: no
 
+# Test data
+#
+# These first files are mere lists of locale identifiers
+Files: src/modules/locale/tests/locale-data-neon src/modules/locale/tests/locale-data-freebsd
+License: CC0-1.0
+Copyright: no
+
 ### TRANSLATIONS
 #
 # .desktop files and template change only with translation
@@ -76,10 +92,3 @@ Files: lang/python/*/LC_MESSAGES/python.po
 License: GPL-3.0-or-later
 Copyright: 2020 Calamares authors and translators
 
-Files: src/modules/dummypythonqt/lang/dummypythonqt.pot
-License: GPL-3.0-or-later
-Copyright: 2020 Calamares authors and translators
-
-Files: src/modules/dummypythonqt/lang/*/LC_MESSAGES/dummypythonqt.po
-License: GPL-3.0-or-later
-Copyright: 2020 Calamares authors and translators

.travis.yml

@@ -1,23 +0,0 @@
-#   SPDX-FileCopyrightText: no
-#   SPDX-License-Identifier: CC0-1.0
-#
-language: cpp
-
-python:
-  - 3.5
-
-sudo: required
-
-services:
-  - docker
-
-notifications:
-  irc:
-    - "chat.freenode.net#calamares"
-
-install:
-  - docker build -t calamares .
-
-script:
-  - docker run -v $PWD:/src --tmpfs /build:rw,size=112M -e SRCDIR=/src -e BUILDDIR=/build calamares "/src/ci/travis.sh"
-

.tx/config

@@ -2,23 +2,23 @@
 #   SPDX-License-Identifier: CC0-1.0
 
 [main]
-host = https://www.transifex.com
+host = https://app.transifex.com
 
-[calamares.calamares]
+[o:calamares:p:calamares:r:calamares]
 file_filter = lang/calamares_<lang>.ts
 source_file = lang/calamares_en.ts
 source_lang = en
-type = QT
+type        = QT
 
-[calamares.fdo]
+[o:calamares:p:calamares:r:fdo]
 file_filter = lang/desktop_<lang>.desktop
 source_file = calamares.desktop
 source_lang = en
-type = DESKTOP
+type        = DESKTOP
 
-[calamares.python]
+[o:calamares:p:calamares:r:python]
 file_filter = lang/python/<lang>/LC_MESSAGES/python.po
 source_file = lang/python.pot
 source_lang = en
-type = PO
+type        = PO
 

3rdparty/kdsingleapplication/CMakeLists.txt

@@ -0,0 +1,26 @@
+set(KDSINGLEAPPLICATION_STATIC ON)
+
+set(KDSINGLEAPPLICATION_SRCS kdsingleapplication.cpp kdsingleapplication_localsocket.cpp)
+
+set(KDSINGLEAPPLICATION_INSTALLABLE_INCLUDES kdsingleapplication.h kdsingleapplication_lib.h)
+
+set(KDSINGLEAPPLICATION_NON_INSTALLABLE_INCLUDES kdsingleapplication_localsocket_p.h)
+
+if(KDSINGLEAPPLICATION_STATIC)
+    add_library(kdsingleapplication STATIC ${KDSINGLEAPPLICATION_INSTALLABLE_INCLUDES} ${KDSINGLEAPPLICATION_SRCS})
+    target_compile_definitions(kdsingleapplication PUBLIC KDSINGLEAPPLICATION_STATIC_BUILD)
+else()
+    add_library(kdsingleapplication SHARED ${KDSINGLEAPPLICATION_INSTALLABLE_INCLUDES} ${KDSINGLEAPPLICATION_SRCS})
+    target_compile_definitions(kdsingleapplication PRIVATE KDSINGLEAPPLICATION_SHARED_BUILD)
+endif()
+set_target_properties( kdsingleapplication PROPERTIES AUTOMOC TRUE )
+
+set(KDSINGLEAPPLICATION_INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR}/kdsingleapplication)
+
+target_include_directories(
+    kdsingleapplication
+    PUBLIC $<INSTALL_INTERFACE:${KDSINGLEAPPLICATION_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(kdsingleapplication ${qtname}::Core ${qtname}::Network)

3rdparty/kdsingleapplication/LICENSE.MIT.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

3rdparty/kdsingleapplication/kdsingleapplication.cpp

@@ -0,0 +1,123 @@
+/*
+    MIT License
+
+    Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+
+#include "kdsingleapplication.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QFileInfo>
+
+// TODO: make this pluggable.
+#include "kdsingleapplication_localsocket_p.h"
+
+// Avoiding dragging in Qt private APIs for now, so this does not inherit
+// from QObjectPrivate.
+class KDSingleApplicationPrivate
+{
+public:
+    explicit KDSingleApplicationPrivate(const QString &name, KDSingleApplication *q);
+
+    void initialize();
+
+    QString name() const
+    {
+        return m_name;
+    }
+
+    bool isPrimaryInstance() const
+    {
+        return m_impl.isPrimaryInstance();
+    }
+
+    bool sendMessage(const QByteArray &message, int timeout)
+    {
+        return m_impl.sendMessage(message, timeout);
+    }
+
+private:
+    Q_DECLARE_PUBLIC(KDSingleApplication)
+
+    KDSingleApplication *q_ptr;
+    QString m_name;
+
+    KDSingleApplicationLocalSocket m_impl;
+};
+
+KDSingleApplicationPrivate::KDSingleApplicationPrivate(const QString &name, KDSingleApplication *q)
+    : q_ptr(q)
+    , m_name(name)
+    , m_impl(name)
+{
+    if (Q_UNLIKELY(name.isEmpty()))
+        qFatal("KDSingleApplication requires a non-empty application name");
+
+    if (isPrimaryInstance()) {
+        QObject::connect(&m_impl, &KDSingleApplicationLocalSocket::messageReceived,
+                         q, &KDSingleApplication::messageReceived);
+    }
+}
+
+static QString extractExecutableName(const QString &applicationFilePath)
+{
+    return QFileInfo(applicationFilePath).fileName();
+}
+
+KDSingleApplication::KDSingleApplication(QObject *parent)
+    : KDSingleApplication(extractExecutableName(QCoreApplication::applicationFilePath()), parent)
+{
+}
+
+KDSingleApplication::KDSingleApplication(const QString &name, QObject *parent)
+    : QObject(parent)
+    , d_ptr(new KDSingleApplicationPrivate(name, this))
+{
+}
+
+QString KDSingleApplication::name() const
+{
+    Q_D(const KDSingleApplication);
+    return d->name();
+}
+
+bool KDSingleApplication::isPrimaryInstance() const
+{
+    Q_D(const KDSingleApplication);
+    return d->isPrimaryInstance();
+}
+
+bool KDSingleApplication::sendMessage(const QByteArray &message)
+{
+    return sendMessageWithTimeout(message, 5000);
+}
+
+bool KDSingleApplication::sendMessageWithTimeout(const QByteArray &message, int timeout)
+{
+    Q_ASSERT(!isPrimaryInstance());
+
+    Q_D(KDSingleApplication);
+    return d->sendMessage(message, timeout);
+}
+
+
+KDSingleApplication::~KDSingleApplication() = default;
+

3rdparty/kdsingleapplication/kdsingleapplication.h

@@ -0,0 +1,62 @@
+/*
+    MIT License
+
+    Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+#ifndef KDSINGLEAPPLICATION_H
+#define KDSINGLEAPPLICATION_H
+
+#include <QtCore/QObject>
+
+#include <memory>
+
+#include "kdsingleapplication_lib.h"
+
+class KDSingleApplicationPrivate;
+
+class KDSINGLEAPPLICATION_EXPORT KDSingleApplication : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name CONSTANT)
+    Q_PROPERTY(bool isPrimaryInstance READ isPrimaryInstance CONSTANT)
+
+public:
+    explicit KDSingleApplication(QObject *parent = nullptr);
+    explicit KDSingleApplication(const QString &name, QObject *parent = nullptr);
+    ~KDSingleApplication();
+
+    QString name() const;
+    bool isPrimaryInstance() const;
+
+public Q_SLOTS:
+    // avoid default arguments and overloads, as they don't mix with connections
+    bool sendMessage(const QByteArray &message);
+    bool sendMessageWithTimeout(const QByteArray &message, int timeout);
+
+Q_SIGNALS:
+    void messageReceived(const QByteArray &message);
+
+private:
+    Q_DECLARE_PRIVATE(KDSingleApplication)
+    std::unique_ptr<KDSingleApplicationPrivate> d_ptr;
+};
+
+#endif // KDSINGLEAPPLICATION_H

3rdparty/kdsingleapplication/kdsingleapplication_lib.h

@@ -0,0 +1,37 @@
+/*
+    MIT License
+
+    Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+#ifndef KDSINGLEAPPLICATION_LIB_H
+#define KDSINGLEAPPLICATION_LIB_H
+
+#include <QtCore/QtGlobal>
+
+#if defined(KDSINGLEAPPLICATION_STATIC_BUILD)
+#define KDSINGLEAPPLICATION_EXPORT
+#elif defined(KDSINGLEAPPLICATION_SHARED_BUILD)
+#define KDSINGLEAPPLICATION_EXPORT Q_DECL_EXPORT
+#else
+#define KDSINGLEAPPLICATION_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // KDSINGLEAPPLICATION_LIB_H

3rdparty/kdsingleapplication/kdsingleapplication_localsocket.cpp

@@ -0,0 +1,304 @@
+/*
+    MIT License
+
+    Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+
+#include "kdsingleapplication_localsocket_p.h"
+
+#include <QtCore/QDir>
+#include <QtCore/QDeadlineTimer>
+#include <QtCore/QTimer>
+#include <QtCore/QLockFile>
+#include <QtCore/QDataStream>
+
+#include <QtCore/QtDebug>
+#include <QtCore/QLoggingCategory>
+
+#include <QtNetwork/QLocalServer>
+#include <QtNetwork/QLocalSocket>
+
+#include <chrono>
+#include <algorithm>
+
+#if defined(Q_OS_UNIX)
+// for ::getuid()
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#if defined(Q_OS_WIN)
+#include <qt_windows.h>
+#endif
+
+static const auto LOCALSOCKET_CONNECTION_TIMEOUT = std::chrono::seconds(5);
+static const char LOCALSOCKET_PROTOCOL_VERSION = 2;
+
+Q_LOGGING_CATEGORY(kdsaLocalSocket, "kdsingleapplication.localsocket", QtWarningMsg);
+
+KDSingleApplicationLocalSocket::KDSingleApplicationLocalSocket(const QString &name, QObject *parent)
+    : QObject(parent)
+{
+#if defined(Q_OS_UNIX)
+    m_socketName = QStringLiteral("kdsingleapp-%1-%2-%3")
+            .arg(::getuid())
+            .arg(qEnvironmentVariable("XDG_SESSION_ID"), name);
+#elif defined(Q_OS_WIN)
+    // I'm not sure of a "global session identifier" on Windows; are
+    // multiple logins from the same user a possibility? For now, following this:
+    // https://docs.microsoft.com/en-us/windows/desktop/devnotes/getting-the-session-id-of-the-current-process
+
+    DWORD sessionId;
+    BOOL haveSessionId = ProcessIdToSessionId(GetCurrentProcessId(), &sessionId);
+
+    m_socketName = QString::fromUtf8("kdsingleapp-%1-%2")
+            .arg(haveSessionId ? sessionId : 0)
+            .arg(name);
+#else
+#error "KDSingleApplication has not been ported to this platform"
+#endif
+
+    const QString lockFilePath =
+            QDir::tempPath() + QLatin1Char('/') + m_socketName + QLatin1String(".lock");
+
+    qCDebug(kdsaLocalSocket) << "Socket name is" << m_socketName;
+    qCDebug(kdsaLocalSocket) << "Lock file path is" << lockFilePath;
+
+    std::unique_ptr<QLockFile> lockFile(new QLockFile(lockFilePath));
+    lockFile->setStaleLockTime(0);
+
+    if (!lockFile->tryLock()) {
+        // someone else has the lock => we're secondary
+        return;
+    }
+
+    std::unique_ptr<QLocalServer> server = std::make_unique<QLocalServer>();
+    if (!server->listen(m_socketName)) {
+        // maybe the primary crashed, leaving a stale socket; delete it and try again
+        QLocalServer::removeServer(m_socketName);
+        if (!server->listen(m_socketName)) {
+            // TODO: better error handling.
+            qWarning("KDSingleApplication: unable to make the primary instance listen on %ls: %ls",
+                     qUtf16Printable(m_socketName),
+                     qUtf16Printable(server->errorString()));
+
+            return;
+        }
+    }
+
+    connect(server.get(), &QLocalServer::newConnection,
+            this, &KDSingleApplicationLocalSocket::handleNewConnection);
+
+    m_lockFile = std::move(lockFile);
+    m_localServer = std::move(server);
+}
+
+KDSingleApplicationLocalSocket::~KDSingleApplicationLocalSocket() = default;
+
+bool KDSingleApplicationLocalSocket::isPrimaryInstance() const
+{
+    return m_localServer != nullptr;
+}
+
+bool KDSingleApplicationLocalSocket::sendMessage(const QByteArray &message, int timeout)
+{
+    Q_ASSERT(!isPrimaryInstance());
+    QLocalSocket socket;
+
+    qCDebug(kdsaLocalSocket) << "Preparing to send message" << message << "with timeout" << timeout;
+
+    QDeadlineTimer deadline(timeout);
+
+    // There is an inherent race here with the setup of the server side.
+    // Even if the socket lock is held by the server, the server may not
+    // be listening yet. So this connection may fail; keep retrying
+    // until we hit the timeout.
+    do {
+        socket.connectToServer(m_socketName);
+        if (socket.waitForConnected(deadline.remainingTime()))
+            break;
+    } while (!deadline.hasExpired());
+
+    qCDebug(kdsaLocalSocket) << "Socket state:" << socket.state() << "Timer remaining" << deadline.remainingTime() << "Expired?" << deadline.hasExpired();
+
+    if (deadline.hasExpired())
+        return false;
+
+    socket.write(&LOCALSOCKET_PROTOCOL_VERSION, 1);
+
+    {
+        QByteArray encodedMessage;
+        QDataStream ds(&encodedMessage, QIODevice::WriteOnly);
+        ds << message;
+        socket.write(encodedMessage);
+    }
+
+    qCDebug(kdsaLocalSocket) << "Wrote message in the socket" << "Timer remaining" << deadline.remainingTime() << "Expired?" << deadline.hasExpired();
+
+    // There is no acknowledgement mechanism here.
+    // Should there be one?
+
+    while (socket.bytesToWrite() > 0) {
+        if (!socket.waitForBytesWritten(deadline.remainingTime()))
+            return false;
+    }
+
+    qCDebug(kdsaLocalSocket) << "Bytes written, now disconnecting" << "Timer remaining" << deadline.remainingTime() << "Expired?" << deadline.hasExpired();
+
+    socket.disconnectFromServer();
+
+    if (socket.state() == QLocalSocket::UnconnectedState)
+        return true;
+
+    if (!socket.waitForDisconnected(deadline.remainingTime()))
+        return false;
+
+    qCDebug(kdsaLocalSocket) << "Disconnected -- success!";
+
+    return true;
+}
+
+void KDSingleApplicationLocalSocket::handleNewConnection()
+{
+    Q_ASSERT(m_localServer);
+
+    QLocalSocket *socket = m_localServer->nextPendingConnection();
+
+    qCDebug(kdsaLocalSocket) << "Got new connection on" << m_socketName << "state" << socket->state();
+
+    Connection c(socket);
+
+    c.readDataConnection = QObjectConnectionHolder(
+                connect(c.socket.get(), &QLocalSocket::readyRead,
+                        this, &KDSingleApplicationLocalSocket::readDataFromSecondary));
+
+    c.secondaryDisconnectedConnection = QObjectConnectionHolder(
+                connect(c.socket.get(), &QLocalSocket::disconnected,
+                        this, &KDSingleApplicationLocalSocket::secondaryDisconnected));
+
+    c.abortConnection = QObjectConnectionHolder(
+                connect(c.timeoutTimer.get(), &QTimer::timeout,
+                        this, &KDSingleApplicationLocalSocket::abortConnectionToSecondary));
+
+    m_clients.push_back(std::move(c));
+
+    // Note that by the time we get here, the socket could've already been closed,
+    // and no signals emitted (hello, Windows!). Read what's already in the socket.
+    if (readDataFromSecondarySocket(socket))
+        return;
+
+    if (socket->state() == QLocalSocket::UnconnectedState)
+        secondarySocketDisconnected(socket);
+}
+
+template <typename Container>
+static auto findConnectionBySocket(Container &container, QLocalSocket *socket)
+{
+    auto i = std::find_if(container.begin(),
+                          container.end(),
+                          [socket](const auto &c) { return c.socket.get() == socket; });
+    Q_ASSERT(i != container.end());
+    return i;
+}
+
+template <typename Container>
+static auto findConnectionByTimer(Container &container, QTimer *timer)
+{
+    auto i = std::find_if(container.begin(),
+                          container.end(),
+                          [timer](const auto &c) { return c.timeoutTimer.get() == timer; });
+    Q_ASSERT(i != container.end());
+    return i;
+}
+
+void KDSingleApplicationLocalSocket::readDataFromSecondary()
+{
+    QLocalSocket *socket = static_cast<QLocalSocket *>(sender());
+    readDataFromSecondarySocket(socket);
+}
+
+bool KDSingleApplicationLocalSocket::readDataFromSecondarySocket(QLocalSocket *socket)
+{
+    auto i = findConnectionBySocket(m_clients, socket);
+    Connection &c = *i;
+    c.readData.append(socket->readAll());
+
+    qCDebug(kdsaLocalSocket) << "Got more data from a secondary. Data read so far:" << c.readData;
+
+    const QByteArray &data = c.readData;
+
+    if (data.size() >= 1) {
+        if (data[0] != LOCALSOCKET_PROTOCOL_VERSION) {
+            qCDebug(kdsaLocalSocket) << "Got an invalid protocol version";
+            m_clients.erase(i);
+            return true;
+        }
+    }
+
+    QDataStream ds(data);
+    ds.skipRawData(1);
+
+    ds.startTransaction();
+    QByteArray message;
+    ds >> message;
+
+    if (ds.commitTransaction()) {
+        qCDebug(kdsaLocalSocket) << "Got a complete message:" << message;
+        Q_EMIT messageReceived(message);
+        m_clients.erase(i);
+        return true;
+    }
+
+    return false;
+}
+
+void KDSingleApplicationLocalSocket::secondaryDisconnected()
+{
+    QLocalSocket *socket = static_cast<QLocalSocket *>(sender());
+    secondarySocketDisconnected(socket);
+}
+
+void KDSingleApplicationLocalSocket::secondarySocketDisconnected(QLocalSocket *socket)
+{
+    auto i = findConnectionBySocket(m_clients, socket);
+    Connection c = std::move(*i);
+    m_clients.erase(i);
+
+    qCDebug(kdsaLocalSocket) << "Secondary disconnected. Data read:" << c.readData;
+}
+
+void KDSingleApplicationLocalSocket::abortConnectionToSecondary()
+{
+    QTimer *timer = static_cast<QTimer *>(sender());
+
+    auto i = findConnectionByTimer(m_clients, timer);
+    Connection c = std::move(*i);
+    m_clients.erase(i);
+
+    qCDebug(kdsaLocalSocket) << "Secondary timed out. Data read:" << c.readData;
+}
+
+KDSingleApplicationLocalSocket::Connection::Connection(QLocalSocket *socket)
+    : socket(socket)
+    , timeoutTimer(new QTimer)
+{
+    timeoutTimer->start(LOCALSOCKET_CONNECTION_TIMEOUT);
+}

3rdparty/kdsingleapplication/kdsingleapplication_localsocket_p.h

@@ -0,0 +1,133 @@
+/*
+    MIT License
+
+    Copyright (C) 2019-2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+*/
+
+#ifndef KDSINGLEAPPLICATION_LOCALSOCKET_P_H
+#define KDSINGLEAPPLICATION_LOCALSOCKET_P_H
+
+#include <QtCore/QObject>
+#include <QtCore/QByteArray>
+#include <QtCore/QString>
+
+QT_BEGIN_NAMESPACE
+class QLockFile;
+class QLocalServer;
+class QLocalSocket;
+class QTimer;
+QT_END_NAMESPACE
+
+#include <memory>
+#include <vector>
+
+struct QObjectDeleteLater
+{
+    void operator()(QObject *o) { o->deleteLater(); }
+};
+
+class QObjectConnectionHolder
+{
+    Q_DISABLE_COPY(QObjectConnectionHolder)
+    QMetaObject::Connection c;
+
+public:
+    QObjectConnectionHolder() {}
+
+    explicit QObjectConnectionHolder(QMetaObject::Connection c)
+        : c(std::move(c))
+    {
+    }
+
+    ~QObjectConnectionHolder()
+    {
+        QObject::disconnect(c);
+    }
+
+    QObjectConnectionHolder(QObjectConnectionHolder &&other) noexcept
+        : c(std::exchange(other.c, {}))
+    {}
+
+    QObjectConnectionHolder &operator=(QObjectConnectionHolder &&other) noexcept
+    {
+        QObjectConnectionHolder moved(std::move(other));
+        swap(moved);
+        return *this;
+    }
+
+    void swap(QObjectConnectionHolder &other) noexcept
+    {
+        using std::swap;
+        swap(c, other.c);
+    }
+};
+
+class KDSingleApplicationLocalSocket : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit KDSingleApplicationLocalSocket(const QString &name,
+                                            QObject *parent = nullptr);
+    ~KDSingleApplicationLocalSocket();
+
+    bool isPrimaryInstance() const;
+
+public Q_SLOTS:
+    bool sendMessage(const QByteArray &message, int timeout);
+
+Q_SIGNALS:
+    void messageReceived(const QByteArray &message);
+
+private:
+    void handleNewConnection();
+    void readDataFromSecondary();
+    bool readDataFromSecondarySocket(QLocalSocket *socket);
+    void secondaryDisconnected();
+    void secondarySocketDisconnected(QLocalSocket *socket);
+    void abortConnectionToSecondary();
+
+    QString m_socketName;
+
+    std::unique_ptr<QLockFile> m_lockFile; // protects m_localServer
+    std::unique_ptr<QLocalServer> m_localServer;
+
+    struct Connection {
+        explicit Connection(QLocalSocket *s);
+
+        std::unique_ptr<QLocalSocket, QObjectDeleteLater> socket;
+        std::unique_ptr<QTimer, QObjectDeleteLater> timeoutTimer;
+        QByteArray readData;
+
+        // socket/timeoutTimer are deleted via deleteLater (as we delete them
+        // in slots connected to their signals). Before the deleteLater is acted upon,
+        // they may emit further signals, triggering logic that it's not supposed
+        // to be triggered (as the Connection has already been destroyed).
+        // Use this Holder to break the connections.
+        QObjectConnectionHolder readDataConnection;
+        QObjectConnectionHolder secondaryDisconnectedConnection;
+        QObjectConnectionHolder abortConnection;
+    };
+
+    std::vector<Connection> m_clients;
+};
+
+#endif // KDSINGLEAPPLICATION_LOCALSOCKET_P_H

3rdparty/kdsingleapplication/src.pro

@@ -0,0 +1,20 @@
+include(../common.pri)
+
+TEMPLATE = lib
+TARGET = kdsingleapplication
+QT = core network
+CONFIG += static
+
+SOURCES += \
+    kdsingleapplication.cpp \
+    kdsingleapplication_localsocket.cpp \
+
+HEADERS += \
+    kdsingleapplication.h \
+    kdsingleapplication_lib.h \
+    kdsingleapplication_localsocket_p.h \
+
+DEFINES += \
+    KDSINGLEAPPLICATION_BUILD
+
+win32:LIBS += -lkernel32

3rdparty/kdsingleapplicationguard/LICENSE.LGPL.txt

@@ -1,488 +0,0 @@
-
- The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
-
- You may use, distribute and copy the KD Tools Library under the terms of
- GNU Library General Public License version 2, which is displayed below.
-
--------------------------------------------------------------------------
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

3rdparty/kdsingleapplicationguard/kdlockedsharedmemorypointer.cpp

@@ -1,481 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#include "kdlockedsharedmemorypointer.h"
-
-#if QT_VERSION >= 0x040400 || defined( DOXYGEN_RUN )
-#ifndef QT_NO_SHAREDMEMORY
-
-namespace kdtools
-{
-}
-using namespace kdtools;
-
-KDLockedSharedMemoryPointerBase::KDLockedSharedMemoryPointerBase( QSharedMemory * m )
-    : locker( m ),
-      mem( m )
-{
-
-}
-
-KDLockedSharedMemoryPointerBase::KDLockedSharedMemoryPointerBase( QSharedMemory & m )
-    : locker( &m ),
-      mem( &m )
-{
-
-}
-
-KDLockedSharedMemoryPointerBase::~KDLockedSharedMemoryPointerBase() {}
-
-void * KDLockedSharedMemoryPointerBase::get() {
-    return mem ? mem->data() : 0 ;
-}
-
-const void * KDLockedSharedMemoryPointerBase::get() const {
-    return mem ? mem->data() : 0 ;
-}
-
-size_t KDLockedSharedMemoryPointerBase::byteSize() const {
-    return mem ? mem->size() : 0;
-}
-
-/*!
-  \class KDLockedSharedMemoryPointer
-  \ingroup core raii smartptr
-  \brief Locking pointer for Qt shared memory segments
-  \since_c 2.1
-
-  (The exception safety of this class has not been evaluated yet.)
-
-  KDLockedSharedMemoryPointer is a smart immutable pointer, which gives convenient and safe access to a QSharedMemory data segment.
-  The content of a KDLockedSharedMemoryPointer cannot be changed during it's lifetime.
-
-  You can use this class like a normal pointer to the shared memory segment and be sure it's locked while accessing it.
-  \note You can only put simple types/structs/classes into it. structs and classes shall not contain any other pointers. See the
-  documentation of QSharedMemory for details.
-*/
-
-/*!
-  \fn KDLockedSharedMemoryPointer::KDLockedSharedMemoryPointer( QSharedMemory * mem )
-
-  Constructor. Constructs a KDLockedSharedMemory pointer which points to the data segment of \a mem.
-  The constructor locks \a mem. If the memory segment is already locked by another process, this constructor
-  blocks until the lock is released.
-
-  \post data() == mem->data() and the memory segment has been locked
-*/
-
-/*!
-  \fn KDLockedSharedMemoryPointer::KDLockedSharedMemoryPointer( QSharedMemory & mem )
-
-  \overload
-
-  \post data() == mem.data() and the memory segment has been locked
-*/
-
-/*!
-  \fn KDLockedSharedMemoryPointer::~KDLockedSharedMemoryPointer()
-
-  Destructor. Unlocks the shared memory segment.
-
-  \post The shared memory segment has been unlocked
-*/
-
-/*!
-  \fn T * KDLockedSharedMemoryPointer::get()
-
-  \returns a pointer to the contained object.
-*/
-
-/*!
-  \fn const T * KDLockedSharedMemoryPointer::get() const
-
-  \returns a const pointer to the contained object
-  \overload
-*/
-
-/*!
-  \fn T * KDLockedSharedMemoryPointer::data()
-
-  Equivalent to get(), provided for consistency with Qt naming conventions.
-*/
-
-/*!
-  \fn const T * KDLockedSharedMemoryPointer::data() const
-
-  \overload
-*/
-
-/*!
-  \fn T & KDLockedSharedMemoryPointer::operator*()
-
-  Dereference operator. Returns \link get() *get()\endlink.
-*/
-
-/*!
-  \fn const T & KDLockedSharedMemoryPointer::operator*() const
-
-  Dereference operator. Returns \link get() *get()\endlink.
-  \overload
-*/
-
-/*!
-  \fn T * KDLockedSharedMemoryPointer::operator->()
-
-  Member-by-pointer operator. Returns get().
-*/
-
-/*!
-  \fn const T * KDLockedSharedMemoryPointer::operator->() const
-
-  Member-by-pointer operator. Returns get().
-  \overload
-*/
-
-/*!
-  \class KDLockedSharedMemoryArray
-  \ingroup core raii smartptr
-  \brief Locking array pointer to Qt shared memory segments
-  \since_c 2.1
-
-  (The exception safety of this class has not been evaluated yet.)
-
-  KDLockedSharedMemoryArray is a smart immutable pointer, which gives convenient and safe access to array data stored in a QSharedMemory
-  data segment.
-  The content of a KDLockedSharedMemoryArray cannot be changed during it's lifetime.
-
-  You can use this class like a normal pointer to the shared memory segment and be sure it's locked while accessing it.
-  \note You can only put arrays of simple types/structs/classes into it. structs and classes shall not contain any other pointers. See the
-  documentation of QSharedMemory for details.
-
-  \sa KDLockedSharedMemoryPointer
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::KDLockedSharedMemoryArray( QSharedMemory* mem )
-  Constructor. Constructs a KDLockedSharedMemoryArray which points to the data segment of \a mem. The constructor locks \a mem. If the memory
-  segment is already locked by another process, this constructor blocks until the lock is release.
-
-  \post get() == mem->data() and the memory segment has been locked
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::KDLockedSharedMemoryArray( QSharedMemory& mem )
-  \overload
-
-  \post get() == mem->data() and the memory segment has been locked
-*/
-
-
-/*!
-  \typedef KDLockedSharedMemoryArray::size_type
-  Typedef for std::size_t. Provided for STL compatibility.
-*/
-
-/*!
-  \typedef KDLockedSharedMemoryArray::difference_type
-  Typedef for std::ptrdiff_t. Provided for STL compatibility.
-*/
-
-/*!
-  \typedef KDLockedSharedMemoryArray::iterator
-  Typedef for T*. Provided for STL compatibility.
-  \since_t 2.2
-*/
-
-/*!
-  \typedef KDLockedSharedMemoryArray::const_iterator
-  Typedef for const T*. Provided for STL compatibility.
-  \since_t 2.2
-*/
-
-/*!
-  \typedef KDLockedSharedMemoryArray::reverse_iterator
-  Typedef for std::reverse_iterator< \link KDLockedSharedMemoryArray::iterator iterator\endlink >. Provided for STL compatibility.
-  \since_t 2.2
-*/
-
-/*!
-  \typedef KDLockedSharedMemoryArray::const_reverse_iterator
-  Typedef for std::reverse_iterator< \link KDLockedSharedMemoryArray::const_iterator const_iterator\endlink >. Provided for STL compatibility.
-  \since_t 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::iterator KDLockedSharedMemoryArray::begin()
-  Returns an \link KDLockedSharedMemoryArray::iterator iterator\endlink pointing to the first item of the array.
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::const_iterator KDLockedSharedMemoryArray::begin() const
-  \overload
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::iterator KDLockedSharedMemoryArray::end()
-  Returns an \link KDLockedSharedMemoryArray::iterator iterator\endlink pointing to the item after the last item of the array.
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::const_iterator KDLockedSharedMemoryArray::end() const
-  \overload
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::reverse_iterator KDLockedSharedMemoryArray::rbegin()
-  Returns an \link KDLockedSharedMemoryArray::reverse_iterator reverse_iterator\endlink pointing to the item after the last item of the array.
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::const_reverse_iterator KDLockedSharedMemoryArray::rbegin() const
-  \overload
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::reverse_iterator KDLockedSharedMemoryArray::rend()
-  Returns an \link KDLockedSharedMemoryArray::reverse_iterator reverse_iterator\endlink pointing to the first item of the array.
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::const_reverse_iterator KDLockedSharedMemoryArray::rend() const
-  \overload
-  \since_f 2.2
-*/
-
-/*!
-  \fn KDLockedSharedMemoryArray::size_type KDLockedSharedMemoryArray::size() const
-  Returns the size of this array. The size is calculated from the storage size of T and
-  the size of the shared memory segment.
-  \since_f 2.2
-*/
-
-/*!
-  \fn T& KDLockedSharedMemoryArray::operator[]( difference_type n )
-  Array access operator. Returns a reference to the item at index position \a n.
-*/
-
-/*!
-  \fn const T& KDLockedSharedMemoryArray::operator[]( difference_type n ) const
-  \overload
-*/
-
-/*!
- \fn T& KDLockedSharedMemoryArray::front()
- Returns a reference to the first item in the array. This is the same as operator[](0).
-*/
-
-/*!
- \fn const T& KDLockedSharedMemoryArray::front() const
- \overload
-*/
-
-/*!
- \fn T& KDLockedSharedMemoryArray::back()
- Returns a reference to the last item in the array. This is the same as operator[](size()-1).
- \since_f 2.2
-*/
-
-/*!
- \fn const T& KDLockedSharedMemoryArray::back() const
- \overload
- \since_f 2.2
-*/
-
-
-#ifdef eKDTOOLSCORE_UNITTESTS
-
-#include <KDUnitTest/Test>
-
-#include <QThread>
-#include <QUuid>
-
-namespace
-{
-    struct TestStruct
-    {
-        TestStruct( uint nn = 0 )
-            : n( nn ),
-              f( 0.0 ),
-              c( '\0' ),
-              b( false )
-        {
-        }
-        uint n;
-        double f;
-        char c;
-        bool b;
-    };
-
-    bool operator==( const TestStruct& lhs, const TestStruct& rhs )
-    {
-        return lhs.n == rhs.n && lhs.f == rhs.f && lhs.c == rhs.c && lhs.b == rhs.b;
-    }
-
-    class TestThread : public QThread
-    {
-    public:
-        TestThread( const QString& key )
-            : mem( key )
-        {
-            mem.attach();
-        }
-
-        void run()
-        {
-            while( true )
-            {
-                msleep( 100 );
-                kdtools::KDLockedSharedMemoryPointer< TestStruct > p( &mem );
-                if( !p->b )
-                    continue;
-
-                p->n = 5;
-                p->f = 3.14;
-                p->c = 'A';
-                p->b = false;
-                return;
-            }
-        }
-
-        QSharedMemory mem;
-    };
-
-    bool isConst( TestStruct* )
-    {
-        return false;
-    }
-
-    bool isConst( const TestStruct* )
-    {
-        return true;
-    }
-}
-
-
-KDAB_UNITTEST_SIMPLE( KDLockedSharedMemoryPointer, "kdcoretools" ) {
-
-    const QString key = QUuid::createUuid();
-    QSharedMemory mem( key );
-    const bool created = mem.create( sizeof( TestStruct ) );
-    assertTrue( created );
-    if ( !created )
-        return; // don't execute tests if shm coulnd't be created
-
-    // On Windows, shared mem is only available in increments of page
-    // size (4k), so don't fail if the segment is larger:
-    const unsigned long mem_size = mem.size();
-    assertGreaterOrEqual( mem_size, sizeof( TestStruct ) );
-
-    {
-        kdtools::KDLockedSharedMemoryPointer< TestStruct > p( &mem );
-        assertTrue( p );
-        *p = TestStruct();
-        assertEqual( p->n, 0u );
-        assertEqual( p->f, 0.0 );
-        assertEqual( p->c, '\0' );
-        assertFalse( p->b );
-    }
-
-    {
-        TestThread thread( key );
-        assertEqual( thread.mem.key().toStdString(), key.toStdString() );
-        assertEqual( static_cast< unsigned long >( thread.mem.size() ), mem_size );
-        thread.start();
-
-        assertTrue( thread.isRunning() );
-        thread.wait( 2000 );
-        assertTrue( thread.isRunning() );
-
-        {
-            kdtools::KDLockedSharedMemoryPointer< TestStruct > p( &mem );
-            p->b = true;
-        }
-
-        thread.wait( 2000 );
-        assertFalse( thread.isRunning() );
-    }
-
-    {
-        kdtools::KDLockedSharedMemoryPointer< TestStruct > p( &mem );
-        assertEqual( p->n, 5u );
-        assertEqual( p->f, 3.14 );
-        assertEqual( p->c, 'A' );
-        assertFalse( p->b );
-    }
-
-    {
-        kdtools::KDLockedSharedMemoryPointer< TestStruct > p( mem );
-        assertEqual( mem.data(), p.get() );
-        assertEqual( p.get(), p.operator->() );
-        assertEqual( p.get(), &(*p) );
-        assertEqual( p.get(), p.data() );
-        assertFalse( isConst( p.get() ) );
-    }
-
-    {
-        const kdtools::KDLockedSharedMemoryPointer< TestStruct > p( &mem );
-        assertEqual( mem.data(), p.get() );
-        assertEqual( p.get(), p.operator->() );
-        assertEqual( p.get(), &(*p) );
-        assertEqual( p.get(), p.data() );
-        assertTrue( isConst( p.get() ) );
-    }
-
-    {
-        QSharedMemory mem2( key + key );
-        const bool created2 = mem2.create( 16 * sizeof( TestStruct ) );
-        assertTrue( created2 );
-        if ( !created2 )
-            return; // don't execute tests if shm coulnd't be created
-
-        kdtools::KDLockedSharedMemoryArray<TestStruct> a( mem2 );
-        assertTrue( a );
-        assertEqual( a.get(), mem2.data() );
-        assertEqual( &a[0], a.get() );
-
-        a[1] = a[0];
-        assertTrue( a[0] == a[1] );
-
-        TestStruct ts;
-        ts.n = 5;
-        ts.f = 3.14;
-        a[0] = ts;
-        assertFalse( a[0] == a[1] );
-        assertEqual( a.front().n, ts.n );
-        assertEqual( a[0].f, ts.f );
-        a[0].n = 10;
-        assertEqual( a.front().n, 10u );
-        ts = a[0];
-        assertEqual( ts.n, 10u );
-
-        std::vector< TestStruct > v;
-        for( uint i = 0; i < a.size(); ++i )
-            v.push_back( TestStruct( i ) );
-
-        std::copy( v.begin(), v.end(), a.begin() );
-        for( uint i = 0; i < a.size(); ++i )
-            assertEqual( a[ i ].n, i );
-        assertEqual( a.front().n, 0u );
-        assertEqual( a.back().n, a.size() - 1 );
-
-        std::copy( v.begin(), v.end(), a.rbegin() );
-        for( uint i = 0; i < a.size(); ++i )
-            assertEqual( a[ i ].n, a.size() - 1 - i );
-        assertEqual( a.front().n, a.size() - 1 );
-        assertEqual( a.back().n, 0u );
-     }
-
-}
-#endif // KDTOOLSCORE_UNITTESTS
-#endif // QT_NO_SHAREDMEMORY
-#endif // QT_VERSION >= 0x040400 || defined( DOXYGEN_RUN )

3rdparty/kdsingleapplicationguard/kdlockedsharedmemorypointer.h

@@ -1,121 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#ifndef __KDTOOLS__CORE__KDLOCKEDSHAREDMEMORYPOINTER_H__
-#define __KDTOOLS__CORE__KDLOCKEDSHAREDMEMORYPOINTER_H__
-
-#include <QtCore/QtGlobal>
-
-#if QT_VERSION >= 0x040400 || defined( DOXYGEN_RUN )
-#ifndef QT_NO_SHAREDMEMORY
-
-#include "kdsharedmemorylocker.h"
-#include <QtCore/QSharedMemory>
-
-#include <cassert>
-
-#ifndef DOXYGEN_RUN
-namespace kdtools {
-#endif
-
-class KDLockedSharedMemoryPointerBase {
-protected:
-    explicit KDLockedSharedMemoryPointerBase( QSharedMemory * mem );
-    explicit KDLockedSharedMemoryPointerBase( QSharedMemory & mem );
-    ~KDLockedSharedMemoryPointerBase();
-
-    // PENDING(marc) do we really want const propagation here? I
-    // usually declare all my RAII objects const...
-    void * get();
-    const void * get() const;
-
-    KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( get() )
-
-    size_t byteSize() const;
-
-private:
-    KDSharedMemoryLocker locker;
-    QSharedMemory * const mem;
-};
-
-template< typename T>
-class MAKEINCLUDES_EXPORT KDLockedSharedMemoryPointer : KDLockedSharedMemoryPointerBase {
-    KDAB_DISABLE_COPY( KDLockedSharedMemoryPointer );
-public:
-    explicit KDLockedSharedMemoryPointer( QSharedMemory * m )
-        : KDLockedSharedMemoryPointerBase( m ) {}
-    explicit KDLockedSharedMemoryPointer( QSharedMemory & m )
-        : KDLockedSharedMemoryPointerBase( m ) {}
-
-    T * get() { return static_cast<T*>( KDLockedSharedMemoryPointerBase::get() ); }
-    const T * get() const { return static_cast<const T*>( KDLockedSharedMemoryPointerBase::get() ); }
-
-    T * data() { return static_cast<T*>( get() ); }
-    const T * data() const { return static_cast<const T*>( get() ); }
-
-    T & operator*() { assert( get() ); return *get(); }
-    const T & operator*() const { assert( get() ); return *get(); }
-
-    T * operator->() { return get(); }
-    const T * operator->() const { return get(); }
-
-    KDAB_USING_SAFE_BOOL_OPERATOR( KDLockedSharedMemoryPointerBase )
-};
-
-template <typename T>
-class MAKEINCLUDES_EXPORT KDLockedSharedMemoryArray : KDLockedSharedMemoryPointerBase {
-    KDAB_DISABLE_COPY( KDLockedSharedMemoryArray );
-public:
-    explicit KDLockedSharedMemoryArray( QSharedMemory * m )
-        : KDLockedSharedMemoryPointerBase( m ) {}
-    explicit KDLockedSharedMemoryArray( QSharedMemory & m )
-        : KDLockedSharedMemoryPointerBase( m ) {}
-
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef T* iterator;
-    typedef const T* const_iterator;
-    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
-    typedef std::reverse_iterator< iterator > reverse_iterator;
-
-    iterator begin() { return get(); }
-    const_iterator begin() const { return get(); }
-
-    iterator end() { return begin() + size(); }
-    const_iterator end() const { return begin() + size(); }
-
-    reverse_iterator rbegin() { return reverse_iterator( end() ); }
-    const_reverse_iterator rbegin() const { return reverse_iterator( end() ); }
-
-    reverse_iterator rend() { return reverse_iterator( begin() ); }
-    const_reverse_iterator rend() const { return const_reverse_iterator( begin() ); }
-
-    size_type size() const { return byteSize() / sizeof( T ); }
-
-    T * get() { return static_cast<T*>( KDLockedSharedMemoryPointerBase::get() ); }
-    const T * get() const { return static_cast<const T*>( KDLockedSharedMemoryPointerBase::get() ); }
-
-    T & operator[]( difference_type n ) { assert( get() ); return *(get()+n); }
-    const T & operator[]( difference_type n ) const { assert( get() ); return *(get()+n); }
-
-    T & front() { assert( get() ); return *get(); }
-    const T & front() const { assert( get() ); return *get(); }
-
-    T & back() { assert( get() ); return *( get() + size() - 1 ); }
-    const T & back() const { assert( get() ); return *( get() + size() - 1 ); }
-
-    KDAB_USING_SAFE_BOOL_OPERATOR( KDLockedSharedMemoryPointerBase )
-};
-
-#ifndef DOXYGEN_RUN
-}
-#endif
-
-#endif /* QT_NO_SHAREDMEMORY */
-
-#endif /* QT_VERSION >= 0x040400 || defined( DOXYGEN_RUN ) */
-
-#endif /* __KDTOOLS__CORE__KDLOCKEDSHAREDMEMORYPOINTER_H__ */

3rdparty/kdsingleapplicationguard/kdsharedmemorylocker.cpp

@@ -1,46 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#include "kdsharedmemorylocker.h"
-
-#if QT_VERSION >= 0x040400 || defined( DOXYGEN_RUN )
-
-#include <QSharedMemory>
-
-using namespace kdtools;
-
-/*!
-  \class KDSharedMemoryLocker
-  \ingroup raii core
-  \brief Exception-safe and convenient wrapper around QSharedMemory::lock()
-*/
-
-/**
- * Constructor. Locks the shared memory segment \a mem.
- * If another process has locking the segment, this constructor blocks
- * until the lock is released. The memory segments needs to be properly created or attached.
- */
-KDSharedMemoryLocker::KDSharedMemoryLocker( QSharedMemory* mem )
-    : mem( mem )
-{
-    mem->lock();
-}
-
-/**
- * Destructor. Unlocks the shared memory segment associated with this
- * KDSharedMemoryLocker.
- */
-KDSharedMemoryLocker::~KDSharedMemoryLocker()
-{
-    mem->unlock();
-}
-
-#ifdef KDAB_EVAL
-#include KDAB_EVAL
-static const EvalDialogChecker evalChecker( "KD Tools", false );
-#endif
-
-#endif

3rdparty/kdsingleapplicationguard/kdsharedmemorylocker.h

@@ -1,42 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#ifndef __KDTOOLS__CORE__KDSHAREDMEMORYLOCKER_H
-#define __KDTOOLS__CORE__KDSHAREDMEMORYLOCKER_H
-
-#include "kdtoolsglobal.h"
-
-#if QT_VERSION < 0x040400 && !defined( DOXYGEN_RUN )
-#ifdef Q_CC_GNU
-#warning "Can't use KDTools KDSharedMemoryLocker with Qt versions prior to 4.4"
-#endif
-#else
-
-class QSharedMemory;
-
-#ifndef DOXYGEN_RUN
-namespace kdtools
-{
-#endif
-
-class KDTOOLSCORE_EXPORT KDSharedMemoryLocker
-{
-    Q_DISABLE_COPY( KDSharedMemoryLocker )
-public:
-    KDSharedMemoryLocker( QSharedMemory* mem );
-    ~KDSharedMemoryLocker();
-
-private:
-    QSharedMemory* const mem;
-};
-
-#ifndef DOXYGEN_RUN
-}
-#endif
-
-#endif
-
-#endif

3rdparty/kdsingleapplicationguard/kdsingleapplicationguard.h

@@ -1,147 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#ifndef KDTOOLSCORE_KDSINGLEAPPLICATIONGUARD_H
-#define KDTOOLSCORE_KDSINGLEAPPLICATIONGUARD_H
-
-#include <QtCore/QObject>
-
-#ifndef QT_NO_SHAREDMEMORY
-
-#include <QtCore/QStringList>
-#include <QtCore/QMetaType>
-
-#include "pimpl_ptr.h"
-#include "DllMacro.h"
-
-#include <algorithm>
-
-template <typename T> class QVector;
-class QCoreApplication;
-
-class DLLEXPORT KDSingleApplicationGuard : public QObject
-{
-    Q_OBJECT
-    Q_ENUMS( Policy )
-    Q_PROPERTY( bool operational READ isOperational )
-    Q_PROPERTY( bool exitRequested READ isExitRequested )
-    Q_PROPERTY( bool primaryInstance READ isPrimaryInstance NOTIFY becamePrimaryInstance )
-    Q_PROPERTY( Policy policy READ policy WRITE setPolicy NOTIFY policyChanged )
-public:
-    enum Policy
-    {
-        NoPolicy = 0,
-        AutoKillOtherInstances = 1
-    };
-
-    explicit KDSingleApplicationGuard( QObject * parent=nullptr );
-    explicit KDSingleApplicationGuard( Policy policy, QObject * parent=nullptr );
-    explicit KDSingleApplicationGuard( const QStringList & arguments, QObject * parent=nullptr );
-    explicit KDSingleApplicationGuard( const QStringList & arguments, Policy policy, QObject * parent=nullptr );
-    ~KDSingleApplicationGuard() override;
-
-    bool isOperational() const;
-
-    bool isExitRequested() const;
-
-    bool isPrimaryInstance() const;
-
-    Policy policy() const;
-    void setPolicy( Policy policy );
-
-    class Instance;
-
-    QVector<Instance> instances() const;
-
-Q_SIGNALS:
-    void instanceStarted( const KDSingleApplicationGuard::Instance & instance );
-    void instanceExited( const KDSingleApplicationGuard::Instance & instance );
-    void exitRequested();
-    void raiseRequested();
-    void becamePrimaryInstance();
-    void becameSecondaryInstance();
-    void policyChanged( KDSingleApplicationGuard::Policy policy );
-
-public Q_SLOTS:
-    void shutdownOtherInstances();
-    void killOtherInstances();
-
-protected:
-    /*! \reimp */ bool event( QEvent * event ) override;
-
-private:
-#ifndef Q_WS_WIN
-    static void SIGINT_handler( int );
-#endif
-
-private:
-    friend struct ProcessInfo;
-
-    class Private;
-    kdtools::pimpl_ptr< Private > d;
-};
-
-class DLLEXPORT KDSingleApplicationGuard::Instance {
-    friend class ::KDSingleApplicationGuard;
-    friend class ::KDSingleApplicationGuard::Private;
-    Instance( const QStringList &, bool, qint64 );
-public:
-    Instance();
-    Instance( const Instance & other );
-    ~Instance();
-
-    void swap( Instance & other ) {
-        std::swap( d, other.d );
-    }
-
-    Instance & operator=( Instance other ) {
-        swap( other );
-        return *this;
-    }
-
-    bool isNull() const { return !d; }
-    bool isValid() const;
-
-    bool areArgumentsTruncated() const;
-
-    const QStringList & arguments() const;
-    qint64 pid() const;
-
-    void shutdown();
-    void kill();
-    void raise();
-
-private:
-    class Private;
-    Private * d;
-};
-
-namespace std {
-    template <>
-    inline void swap( KDSingleApplicationGuard::Instance & lhs,
-                      KDSingleApplicationGuard::Instance & rhs )
-    {
-        lhs.swap( rhs );
-    }
-} // namespace std
-
-QT_BEGIN_NAMESPACE
-
-template <>
-inline void qSwap( KDSingleApplicationGuard::Instance & lhs,
-                   KDSingleApplicationGuard::Instance & rhs )
-{
-    lhs.swap( rhs );
-}
-Q_DECLARE_METATYPE( KDSingleApplicationGuard::Instance )
-Q_DECLARE_TYPEINFO( KDSingleApplicationGuard::Instance, Q_MOVABLE_TYPE );
-
-QT_END_NAMESPACE
-
-
-#endif // QT_NO_SHAREDMEMORY
-
-#endif /* KDTOOLSCORE_KDSINGLEAPPLICATIONGUARD_H */

3rdparty/kdsingleapplicationguard/kdtoolsglobal.cpp

@@ -1,42 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#include "kdtoolsglobal.h"
-
-#include <QByteArray>
-
-#include <algorithm>
-
-namespace {
-    struct Version {
-	unsigned char v[3];
-    };
-
-    static inline bool operator<( const Version & lhs, const Version & rhs ) {
-	return std::lexicographical_compare( lhs.v, lhs.v + 3, rhs.v, rhs.v + 3 );
-    }
-    static inline bool operator==( const Version & lhs, const Version & rhs ) {
-	return std::equal( lhs.v, lhs.v + 3, rhs.v );
-    }
-    KDTOOLS_MAKE_RELATION_OPERATORS( Version, static inline )
-}
-
-static Version kdParseQtVersion( const char * const version ) {
-    if ( !version || qstrlen( version ) < 5 || version[1] != '.' || version[3] != '.' || ( version[5] != 0 && version[5] != '.' && version[5] != '-' ) )
-	return Version(); // parse error
-    const Version result = { { static_cast< unsigned char >( version[0] - '0' ),
-                               static_cast< unsigned char >( version[2] - '0' ),
-                               static_cast< unsigned char >( version[4] - '0' ) } };
-    return result;
-}
-
-bool _kdCheckQtVersion_impl( unsigned int major, unsigned int minor, unsigned int patchlevel ) {
-    static const Version actual = kdParseQtVersion( qVersion() ); // do this only once each run...
-    const Version requested = { { static_cast< unsigned char >( major ),
-                                  static_cast< unsigned char >( minor ),
-                                  static_cast< unsigned char >( patchlevel ) } };
-    return actual >= requested;
-}

3rdparty/kdsingleapplicationguard/kdtoolsglobal.h

@@ -1,120 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#ifndef KDTOOLS_KDTOOLSGLOBAL_H
-#define KDTOOLS_KDTOOLSGLOBAL_H
-
-#include <QtCore/QtGlobal>
-
-#define KDAB_DISABLE_COPY( x ) private: x( const x & ); x & operator=( const x & )
-
-#ifdef KDTOOLS_SHARED
-#  ifdef BUILD_SHARED_KDTOOLSCORE
-#    define KDTOOLSCORE_EXPORT Q_DECL_EXPORT
-#  else
-#    define KDTOOLSCORE_EXPORT Q_DECL_IMPORT
-#  endif
-#  ifdef BUILD_SHARED_KDTOOLSGUI
-#    define KDTOOLSGUI_EXPORT Q_DECL_EXPORT
-#  else
-#    define KDTOOLSGUI_EXPORT Q_DECL_IMPORT
-#  endif
-#  ifdef BUILD_SHARED_KDTOOLSXML
-#    define KDTOOLSXML_EXPORT Q_DECL_EXPORT
-#  else
-#    define KDTOOLSXML_EXPORT Q_DECL_IMPORT
-#  endif
-#  ifdef BUILD_SHARED_KDUPDATER
-#    define KDTOOLS_UPDATER_EXPORT    Q_DECL_EXPORT
-#  else
-#    define KDTOOLS_UPDATER_EXPORT    Q_DECL_IMPORT
-#  endif
-#else // KDTOOLS_SHARED
-#  define KDTOOLSCORE_EXPORT
-#  define KDTOOLSGUI_EXPORT
-#  define KDTOOLSXML_EXPORT
-#  define KDTOOLS_UPDATER_EXPORT
-#endif // KDTOOLS_SHARED
-
-#define MAKEINCLUDES_EXPORT
-
-#define DOXYGEN_PROPERTY( x )
-#ifdef DOXYGEN_RUN
-# define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( func ) operator unspecified_bool_type() const { return func; }
-# define KDAB_USING_SAFE_BOOL_OPERATOR( Class ) operator unspecified_bool_type() const;
-#else
-# define KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( func )                      \
-    private:                                                            \
-        struct __safe_bool_dummy__ { void nonnull() {} };               \
-    public:                                                             \
-        typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \
-        operator unspecified_bool_type() const {                        \
-            return ( func ) ? &__safe_bool_dummy__::nonnull : 0 ;       \
-        }
-#define KDAB_USING_SAFE_BOOL_OPERATOR( Class ) \
-    using Class::operator Class::unspecified_bool_type;
-#endif
-
-#define KDTOOLS_MAKE_RELATION_OPERATORS( Class, linkage )             \
-    linkage bool operator>( const Class & lhs, const Class & rhs ) {  \
-        return operator<( rhs, lhs );                                 \
-    }                                                                 \
-    linkage bool operator!=( const Class & lhs, const Class & rhs ) { \
-        return !operator==( lhs, rhs );                               \
-    }                                                                 \
-    linkage bool operator<=( const Class & lhs, const Class & rhs ) { \
-        return !operator>( lhs, rhs );                                \
-    }                                                                 \
-    linkage bool operator>=( const Class & lhs, const Class & rhs ) { \
-        return !operator<( lhs, rhs );                                \
-    }
-
-template <typename T>
-inline T & __kdtools__dereference_for_methodcall( T & o ) {
-    return o;
-}
-
-template <typename T>
-inline T & __kdtools__dereference_for_methodcall( T * o ) {
-    return *o;
-}
-
-#define KDAB_SET_OBJECT_NAME( x ) __kdtools__dereference_for_methodcall( x ).setObjectName( QLatin1String( #x ) )
-
-KDTOOLSCORE_EXPORT bool _kdCheckQtVersion_impl( unsigned int major, unsigned int minor=0, unsigned int patchlevel=0 );
-static inline bool kdCheckQtVersion( unsigned int major, unsigned int minor=0, unsigned int patchlevel=0 ) {
-    return (major<<16|minor<<8|patchlevel) <= static_cast<unsigned int>(QT_VERSION)
-	|| _kdCheckQtVersion_impl( major, minor, patchlevel );
-}
-
-#define KDTOOLS_DECLARE_PRIVATE_BASE( Class )                        \
-protected:                                                           \
-    class Private;                                                   \
-    Private * d_func() { return _d; }                                \
-    const Private * d_func() const { return _d; }                    \
-    Class( Private * _d_, bool b ) : _d( _d_ ) { init(b); }          \
-private:                                                             \
-    void init(bool);                                                 \
-private:                                                             \
-    Private * _d
-
-#define KDTOOLS_DECLARE_PRIVATE_DERIVED( Class, Base )                  \
-protected:                                                              \
-    class Private;                                                      \
-    Private * d_func() {                                                \
-        return reinterpret_cast<Private*>( Base::d_func() );            \
-    }                                                                   \
-    const Private * d_func() const {                                    \
-        return reinterpret_cast<const Private*>( Base::d_func() );      \
-    }                                                                   \
-    Class( Private * _d_, bool b )                                      \
-        : Base( reinterpret_cast<Base::Private*>(_d_), b ) { init(b); } \
-private:                                                                \
-    void init(bool)
-
-
-#endif /* KDTOOLS_KDTOOLSGLOBAL_H */
-

3rdparty/kdsingleapplicationguard/pimpl_ptr.cpp

@@ -1,209 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#include "pimpl_ptr.h"
-
-/*!
-  \class pimpl_ptr:
-  \ingroup core smartptr
-  \brief Owning pointer for private implementations
-  \since_c 2.1
-
-  (The exception safety of this class has not been evaluated yet.)
-
-  pimpl_ptr is a smart immutable pointer, which owns the contained object. Unlike other smart pointers,
-  it creates a standard constructed object when instanciated via the
-  \link pimpl_ptr() standard constructor\endlink.
-  Additionally, pimpl_ptr respects constness of the pointer object and returns \c const \c T* for
-  a const pimpl_ptr object.
-
-  The content of a pimpl_ptr cannot be changed during it's lifetime.
-
-  \section general-use General Use
-
-  The general use case of pimpl_ptr is the "Pimpl Idiom", i.e. hiding the private implementation of a class
-  from the user's compiler which see \c MyClass as
-
-  \code
-  class MyClass
-  {
-  public:
-      MyClass();
-      ~MyClass();
-
-      // public class API
-      int value() const;
-
-  private:
-      class Private; // defined later
-      kdtools::pimpl_ptr< Private > d;
-  };
-  \endcode
-
-  but not the private parts of it. These can only be seen (and accessed) by the code knowing \c MyClass::Private:
-
-  \code
-  class MyClass::Private
-  {
-  public:
-      int value;
-  };
-
-  MyClass::MyClass()
-  {
-      // d was automatically filled with new Private
-      d->value = 42;
-  }
-
-  MyClass::~MyClass()
-  {
-      // the content of d gets deleted automatically
-  }
-
-  int MyClass::value() const
-  {
-      // access the private part:
-      // since MyClass::value() is const, the returned pointee is const, too
-      return d->value;
-  }
-  \endcode
-
-*/
-
-/*!
-  \fn pimpl_ptr::pimpl_ptr()
-
-  Default constructor. Constructs a pimpl_tr that contains (owns) a standard constructed
-  instance of \c T.
-
-  \post \c *this owns a new object.
-*/
-
-/*!
-  \fn pimpl_ptr::pimpl_ptr( T * t )
-
-  Constructor. Constructs a pimpl_ptr that contains (owns) \a t.
-
-  \post get() == obj
-*/
-
-/*!
-  \fn pimpl_ptr::~pimpl_ptr()
-
-  Destructor.
-
-  \post The object previously owned by \c *this has been deleted.
-*/
-
-/*!
-  \fn const T * pimpl_ptr::get() const
-
-  \returns a const pointer to the contained (owned) object.
-  \overload
-*/
-
-/*!
-  \fn T * pimpl_ptr::get()
-
-  \returns a pointer to the contained (owned) object.
-*/
-
-/*!
-  \fn const T & pimpl_ptr::operator*() const
-
-  Dereference operator. Returns \link get() *get()\endlink.
-  \overload
-*/
-
-/*!
-  \fn T & pimpl_ptr::operator*()
-
-  Dereference operator. Returns \link get() *get()\endlink.
-*/
-
-/*!
-  \fn const T * pimpl_ptr::operator->() const
-
-  Member-by-pointer operator. Returns get().
-  \overload
-*/
-
-/*!
-  \fn T * pimpl_ptr::operator->()
-
-  Member-by-pointer operator. Returns get().
-*/
-
-#ifdef KDTOOLSCORE_UNITTESTS
-
-#include <kdunittest/test.h>
-
-#include <QObject>
-#include <QPointer>
-
-namespace
-{
-    struct ConstTester
-    {
-        bool isConst()
-        {
-            return false;
-        }
-
-        bool isConst() const
-        {
-            return true;
-        }
-    };
-}
-
-KDAB_UNITTEST_SIMPLE( pimpl_ptr, "kdcoretools" ) {
-
-    {
-        kdtools::pimpl_ptr< QObject > p;
-        assertNotNull( p.get() );
-        assertNull( p->parent() );
-    }
-
-
-    {
-        QPointer< QObject > o;
-        {
-            kdtools::pimpl_ptr< QObject > qobject( new QObject );
-            o = qobject.get();
-            assertEqual( o, qobject.operator->() );
-            assertEqual( o, &(qobject.operator*()) );
-        }
-        assertNull( o );
-    }
-
-    {
-        const kdtools::pimpl_ptr< QObject > qobject( new QObject );
-        const QObject* o = qobject.get();
-        assertEqual( o, qobject.operator->() );
-        assertEqual( o, &(qobject.operator*()) );
-    }
-
-    {
-        kdtools::pimpl_ptr< QObject > o1;
-        assertTrue( o1 );
-        kdtools::pimpl_ptr< QObject > o2( 0 );
-        assertFalse( o2 );
-    }
-
-    {
-        const kdtools::pimpl_ptr< ConstTester > o1;
-        kdtools::pimpl_ptr< ConstTester > o2;
-        assertTrue( o1->isConst() );
-        assertFalse( o2->isConst() );
-        assertTrue( (*o1).isConst() );
-        assertFalse( (*o2).isConst() );
-        assertTrue( o1.get()->isConst() );
-        assertFalse( o2.get()->isConst() );
-    }
-}
-
-#endif // KDTOOLSCORE_UNITTESTS

3rdparty/kdsingleapplicationguard/pimpl_ptr.h

@@ -1,50 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2001-2010 Klaralvdalens Datakonsult AB.
- *   SPDX-License-Identifier: LGPL-2.0-only
- *
- *   The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
- */
-#ifndef KDTOOLSCORE_PIMPL_PTR_H
-#define KDTOOLSCORE_PIMPL_PTR_H
-
-#include "kdtoolsglobal.h"
-
-#ifndef DOXYGEN_RUN
-namespace kdtools {
-#endif
-
-    template <typename T>
-    class pimpl_ptr {
-        KDAB_DISABLE_COPY( pimpl_ptr );
-        T * d;
-    public:
-        pimpl_ptr() : d( new T ) {}
-        explicit pimpl_ptr( T * t ) : d( t ) {}
-        ~pimpl_ptr() { delete d; d = nullptr; }
-
-        T * get() { return d; }
-        const T * get() const { return d; }
-
-        T * operator->() { return get(); }
-        const T * operator->() const { return get(); }
-
-        T & operator*() { return *get(); }
-        const T & operator*() const { return *get(); }
-
-        KDAB_IMPLEMENT_SAFE_BOOL_OPERATOR( get() )
-    };
-
-    // these are not implemented, so's we can catch their use at
-    // link-time. Leaving them undeclared would open up a comparison
-    // via operator unspecified-bool-type().
-    template <typename T, typename S>
-    void operator==( const pimpl_ptr<T> &, const pimpl_ptr<S> & );
-    template <typename T, typename S>
-    void operator!=( const pimpl_ptr<T> &, const pimpl_ptr<S> & );
-
-#ifndef DOXYGEN_RUN
-} // namespace kdtools
-#endif
-
-#endif /* KDTOOLSCORE_PIMPL_PTR_H */
-

3rdparty/waitingspinnerwidget.cpp

@@ -1,284 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2012-2014 Alexander Turkin
- *   SPDX-FileCopyrightText: 2014 William Hallatt
- *   SPDX-FileCopyrightText: 2015 Jacob Dawid
- *   SPDX-License-Identifier: MIT
- */
-
-/* Original Work Copyright (c) 2012-2014 Alexander Turkin
-   Modified 2014 by William Hallatt
-   Modified 2015 by Jacob Dawid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-// Own includes
-#include "waitingspinnerwidget.h"
-
-// Standard includes
-#include <cmath>
-#include <algorithm>
-
-// Qt includes
-#include <QPainter>
-#include <QTimer>
-
-WaitingSpinnerWidget::WaitingSpinnerWidget(QWidget *parent,
-                                           bool centerOnParent,
-                                           bool disableParentWhenSpinning)
-    : QWidget(parent),
-      _centerOnParent(centerOnParent),
-      _disableParentWhenSpinning(disableParentWhenSpinning) {
-    initialize();
-}
-
-WaitingSpinnerWidget::WaitingSpinnerWidget(Qt::WindowModality modality,
-                                           QWidget *parent,
-                                           bool centerOnParent,
-                                           bool disableParentWhenSpinning)
-    : QWidget(parent, Qt::Dialog | Qt::FramelessWindowHint),
-      _centerOnParent(centerOnParent),
-      _disableParentWhenSpinning(disableParentWhenSpinning){
-    initialize();
-
-    // We need to set the window modality AFTER we've hidden the
-    // widget for the first time since changing this property while
-    // the widget is visible has no effect.
-    setWindowModality(modality);
-    setAttribute(Qt::WA_TranslucentBackground);
-}
-
-void WaitingSpinnerWidget::initialize() {
-    _color = Qt::black;
-    _roundness = 100.0;
-    _minimumTrailOpacity = 3.14159265358979323846;
-    _trailFadePercentage = 80.0;
-    _revolutionsPerSecond = 1.57079632679489661923;
-    _numberOfLines = 20;
-    _lineLength = 10;
-    _lineWidth = 2;
-    _innerRadius = 10;
-    _currentCounter = 0;
-    _isSpinning = false;
-
-    _timer = new QTimer(this);
-    connect(_timer, SIGNAL(timeout()), this, SLOT(rotate()));
-    updateSize();
-    updateTimer();
-    hide();
-}
-
-void WaitingSpinnerWidget::paintEvent(QPaintEvent *) {
-    updatePosition();
-    QPainter painter(this);
-    painter.fillRect(this->rect(), Qt::transparent);
-    painter.setRenderHint(QPainter::Antialiasing, true);
-
-    if (_currentCounter >= _numberOfLines) {
-        _currentCounter = 0;
-    }
-
-    painter.setPen(Qt::NoPen);
-    for (int i = 0; i < _numberOfLines; ++i) {
-        painter.save();
-        painter.translate(_innerRadius + _lineLength,
-                          _innerRadius + _lineLength);
-        qreal rotateAngle =
-                static_cast<qreal>(360 * i) / static_cast<qreal>(_numberOfLines);
-        painter.rotate(rotateAngle);
-        painter.translate(_innerRadius, 0);
-        int distance =
-                lineCountDistanceFromPrimary(i, _currentCounter, _numberOfLines);
-        QColor color =
-                currentLineColor(distance, _numberOfLines, _trailFadePercentage,
-                                 _minimumTrailOpacity, _color);
-        painter.setBrush(color);
-        // TODO improve the way rounded rect is painted
-        painter.drawRoundedRect(
-                    QRect(0, -_lineWidth / 2, _lineLength, _lineWidth), _roundness,
-                    _roundness, Qt::RelativeSize);
-        painter.restore();
-    }
-}
-
-void WaitingSpinnerWidget::start() {
-    updatePosition();
-    _isSpinning = true;
-    show();
-
-    if(parentWidget() && _disableParentWhenSpinning) {
-        parentWidget()->setEnabled(false);
-    }
-
-    if (!_timer->isActive()) {
-        _timer->start();
-        _currentCounter = 0;
-    }
-}
-
-void WaitingSpinnerWidget::stop() {
-    _isSpinning = false;
-    hide();
-
-    if(parentWidget() && _disableParentWhenSpinning) {
-        parentWidget()->setEnabled(true);
-    }
-
-    if (_timer->isActive()) {
-        _timer->stop();
-        _currentCounter = 0;
-    }
-}
-
-void WaitingSpinnerWidget::setNumberOfLines(int lines) {
-    _numberOfLines = lines;
-    _currentCounter = 0;
-    updateTimer();
-}
-
-void WaitingSpinnerWidget::setLineLength(int length) {
-    _lineLength = length;
-    updateSize();
-}
-
-void WaitingSpinnerWidget::setLineWidth(int width) {
-    _lineWidth = width;
-    updateSize();
-}
-
-void WaitingSpinnerWidget::setInnerRadius(int radius) {
-    _innerRadius = radius;
-    updateSize();
-}
-
-QColor WaitingSpinnerWidget::color() {
-    return _color;
-}
-
-qreal WaitingSpinnerWidget::roundness() {
-    return _roundness;
-}
-
-qreal WaitingSpinnerWidget::minimumTrailOpacity() {
-    return _minimumTrailOpacity;
-}
-
-qreal WaitingSpinnerWidget::trailFadePercentage() {
-    return _trailFadePercentage;
-}
-
-qreal WaitingSpinnerWidget::revolutionsPersSecond() {
-    return _revolutionsPerSecond;
-}
-
-int WaitingSpinnerWidget::numberOfLines() {
-    return _numberOfLines;
-}
-
-int WaitingSpinnerWidget::lineLength() {
-    return _lineLength;
-}
-
-int WaitingSpinnerWidget::lineWidth() {
-    return _lineWidth;
-}
-
-int WaitingSpinnerWidget::innerRadius() {
-    return _innerRadius;
-}
-
-bool WaitingSpinnerWidget::isSpinning() const {
-    return _isSpinning;
-}
-
-void WaitingSpinnerWidget::setRoundness(qreal roundness) {
-    _roundness = std::max(0.0, std::min(100.0, roundness));
-}
-
-void WaitingSpinnerWidget::setColor(QColor color) {
-    _color = color;
-}
-
-void WaitingSpinnerWidget::setRevolutionsPerSecond(qreal revolutionsPerSecond) {
-    _revolutionsPerSecond = revolutionsPerSecond;
-    updateTimer();
-}
-
-void WaitingSpinnerWidget::setTrailFadePercentage(qreal trail) {
-    _trailFadePercentage = trail;
-}
-
-void WaitingSpinnerWidget::setMinimumTrailOpacity(qreal minimumTrailOpacity) {
-    _minimumTrailOpacity = minimumTrailOpacity;
-}
-
-void WaitingSpinnerWidget::rotate() {
-    ++_currentCounter;
-    if (_currentCounter >= _numberOfLines) {
-        _currentCounter = 0;
-    }
-    update();
-}
-
-void WaitingSpinnerWidget::updateSize() {
-    int size = (_innerRadius + _lineLength) * 2;
-    setFixedSize(size, size);
-}
-
-void WaitingSpinnerWidget::updateTimer() {
-    _timer->setInterval(1000 / (_numberOfLines * _revolutionsPerSecond));
-}
-
-void WaitingSpinnerWidget::updatePosition() {
-    if (parentWidget() && _centerOnParent) {
-        move(parentWidget()->width() / 2 - width() / 2,
-             parentWidget()->height() / 2 - height() / 2);
-    }
-}
-
-int WaitingSpinnerWidget::lineCountDistanceFromPrimary(int current, int primary,
-                                                       int totalNrOfLines) {
-    int distance = primary - current;
-    if (distance < 0) {
-        distance += totalNrOfLines;
-    }
-    return distance;
-}
-
-QColor WaitingSpinnerWidget::currentLineColor(int countDistance, int totalNrOfLines,
-                                              qreal trailFadePerc, qreal minOpacity,
-                                              QColor color) {
-    if (countDistance == 0) {
-        return color;
-    }
-    const qreal minAlphaF = minOpacity / 100.0;
-    int distanceThreshold =
-            static_cast<int>(ceil((totalNrOfLines - 1) * trailFadePerc / 100.0));
-    if (countDistance > distanceThreshold) {
-        color.setAlphaF(minAlphaF);
-    } else {
-        qreal alphaDiff = color.alphaF() - minAlphaF;
-        qreal gradient = alphaDiff / static_cast<qreal>(distanceThreshold + 1);
-        qreal resultAlpha = color.alphaF() - gradient * countDistance;
-
-        // If alpha is out of bounds, clip it.
-        resultAlpha = std::min(1.0, std::max(0.0, resultAlpha));
-        color.setAlphaF(resultAlpha);
-    }
-    return color;
-}

3rdparty/waitingspinnerwidget.h

@@ -1,122 +0,0 @@
-/*
- *   SPDX-FileCopyrightText: 2012-2014 Alexander Turkin
- *   SPDX-FileCopyrightText: 2014 William Hallatt
- *   SPDX-FileCopyrightText: 2015 Jacob Dawid
- *   SPDX-License-Identifier: MIT
- */
-
-/* Original Work Copyright (c) 2012-2014 Alexander Turkin
-   Modified 2014 by William Hallatt
-   Modified 2015 by Jacob Dawid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-// Qt includes
-#include <QWidget>
-#include <QTimer>
-#include <QColor>
-
-class WaitingSpinnerWidget : public QWidget {
-    Q_OBJECT
-public:
-    /*! Constructor for "standard" widget behaviour - use this
-   * constructor if you wish to, e.g. embed your widget in another. */
-    WaitingSpinnerWidget(QWidget *parent = nullptr,
-                         bool centerOnParent = true,
-                         bool disableParentWhenSpinning = true);
-
-    /*! Constructor - use this constructor to automatically create a modal
-   * ("blocking") spinner on top of the calling widget/window.  If a valid
-   * parent widget is provided, "centreOnParent" will ensure that
-   * QtWaitingSpinner automatically centres itself on it, if not,
-   * "centreOnParent" is ignored. */
-    WaitingSpinnerWidget(Qt::WindowModality modality,
-                         QWidget *parent = nullptr,
-                         bool centerOnParent = true,
-                         bool disableParentWhenSpinning = true);
-
-public slots:
-    void start();
-    void stop();
-
-public:
-    void setColor(QColor color);
-    void setRoundness(qreal roundness);
-    void setMinimumTrailOpacity(qreal minimumTrailOpacity);
-    void setTrailFadePercentage(qreal trail);
-    void setRevolutionsPerSecond(qreal revolutionsPerSecond);
-    void setNumberOfLines(int lines);
-    void setLineLength(int length);
-    void setLineWidth(int width);
-    void setInnerRadius(int radius);
-    void setText(QString text);
-
-    QColor color();
-    qreal roundness();
-    qreal minimumTrailOpacity();
-    qreal trailFadePercentage();
-    qreal revolutionsPersSecond();
-    int numberOfLines();
-    int lineLength();
-    int lineWidth();
-    int innerRadius();
-
-    bool isSpinning() const;
-
-private slots:
-    void rotate();
-
-protected:
-    void paintEvent(QPaintEvent *paintEvent) override;
-
-private:
-    static int lineCountDistanceFromPrimary(int current, int primary,
-                                            int totalNrOfLines);
-    static QColor currentLineColor(int distance, int totalNrOfLines,
-                                   qreal trailFadePerc, qreal minOpacity,
-                                   QColor color);
-
-    void initialize();
-    void updateSize();
-    void updateTimer();
-    void updatePosition();
-
-private:
-    QColor  _color;
-    qreal   _roundness; // 0..100
-    qreal   _minimumTrailOpacity;
-    qreal   _trailFadePercentage;
-    qreal   _revolutionsPerSecond;
-    int     _numberOfLines;
-    int     _lineLength;
-    int     _lineWidth;
-    int     _innerRadius;
-
-private:
-    WaitingSpinnerWidget(const WaitingSpinnerWidget&);
-    WaitingSpinnerWidget& operator=(const WaitingSpinnerWidget&);
-
-    QTimer *_timer;
-    bool    _centerOnParent;
-    bool    _disableParentWhenSpinning;
-    int     _currentCounter;
-    bool    _isSpinning;
-};

AUTHORS

@@ -20,29 +20,58 @@ and moral support from (alphabetically by first name or nickname):
  - Allen Welkie
  - AlmAck
  - Andrius Štikonas
+ - Anke Boersma
+ - Anubhav Choudhary
+ - Arjen Balfoort
  - Arnaud Ferraris
+ - Artem Grinev
  - artoo@cromnix.org
+ - benne-dee
  - Bernhard Landauer
  - Bezzy1999
  - Bill Auger
+ - Bob van der Linden
  - Caio Jordão Carvalho
+ - Camilo Higuita
  - Collabora LTD
+ - Corey Lang
  - crispg72
  - Dan Simmons
  - demmm
+ - Emmanuel Arias
+ - Enrique Medina Gremaldos
+ - Erik Dubois
  - Dominic Hayes
+ - El-Wumbus
+ - Evan James
  - Frede H
  - Gabriel Craciunescu
  - Harald Sitter
+ - Huang Jia Wen
+ - Jerrod Frost
+ - Jia Chao
+ - Joe Kamprad
+ - Jonas Strassel
  - Kai Dohmen
  - Kevin Kofler
  - Kyle Robertze
  - Lisa Vitolo
+ - Matti Hyttinen
  - n3rdopolis
+ - Neal Gompa
+ - Nico 'dr460nf1r3'
+ - Omer I.S.
  - Philip Müller
  - Ramon Buldó
  - Raul Rodrigo Segura
  - Rohan Garg
+ - Santosh Mahto
  - Scott Harvey
  - Simon Quigley
+ - Taejun Park
+ - Victor Fuentes
+ - vtriolet
  - Walter Lapchynski
+ - Waneon Kim
+
+ > This list was updated to revision 6e8d820737dea0f3e08f12b10768facef19be684 on May 28th 2022.

CHANGES-3.2

@@ -7,6 +7,844 @@ contributors are listed. Note that Calamares does not have a historical
 changelog -- this log starts with version 3.2.0. The release notes on the
 website will have to do for older versions.
 
+
+Calamares version 3.2.61 is the last one to have updated CHANGES-3.2
+in the *calamares* (e.g. development, or 3.3, branch). For changes
+in the stable release branch, see CHANGES-3.2 in that branch.
+
+
+
+# 3.2.61 (2022-08-24) #
+
+This is the second community-maintainence release of Calamares 3.2.
+It corrects a handful of bugs foud in the stable release. There
+are also translation updates.
+
+This release contains contributions from (alphabetically by first name):
+ - Adriaan de Groot
+ - Anke Boersma
+
+## Core ##
+ - The "About" and "Debug" buttons in a QWidgets-based panel were no
+   longer translated. This has been fixed (by re-using translations
+   of the same buttons from the QML module. #2030 (Thanks Anke)
+
+## Modules ##
+ - *bootloader* Python code slipped in that was incompatible with
+   the minimum required Python version. #2033 (Thanks Adriaan)
+ - *locale* fixes a large regression introduced with 3.2.60, where
+   the location picked for many locales was not the same as in 3.2.59,
+   and generally peculiar (e.g. picking "English" led to "en_AG" which
+   is nice if you are in Bermuda, but not expected in the rest of the
+   world). #2008
+ - *luksopenswaphookcfg* Remove duplicate options. #1659 (Thanks Anke)
+
+
+# 3.2.60 (2022-06-19) #
+
+This is the first community-maintainence release of Calamares 3.2.
+Somewhat ironically, all the commits in the branch come from
+Adriaan de Groot -- the community is working in the 3.3 (*calamares*)
+branch.
+
+## Core ##
+ - No core changes
+
+## Modules ##
+ - *fstab* now warns when the mount options are empty (which is non-
+   sensical, and indicates that the configuration is bad).
+ - *locale* does a better job of preserving Catalan (Valencia)
+   across modules; previously it dropped the *Valencia*
+   after the locale module unless you specifically re-selected
+   `ca@valencia` in the locale module. (Reported by Lliurex)
+ - *welcome* now has text labels on the special buttons (nominally,
+   this is part of the core, but the *About* button was always on the
+   welcome page).
+
+
+# 3.2.59 (2022-05-29) #
+
+This release contains contributions from (alphabetically by first name):
+ - Arjen Balfoort
+
+This is the final release of Calamares 3.2 where the release is from
+the *calamares* branch -- that is, where the primary development
+branch is also the branch being released regularly. Future releases
+of the 3.2 series are bugfix-only, and no new feature development
+or translations are expected. This is also the final release done
+*as work-work* by the current maintainer.
+
+## Core ##
+ - Prep-work for moving the *About Calamares* button to the panels,
+   rather than keeping it in the Welcome module. The about information
+   is somewhat more flexible now, so that a new maintainer can be added
+   easily without frustrating translators.
+ - The progress panels (both Widgets and QML) now have an About button
+   on them, showing the traditional *About Calamares* dialog.
+ - Translations for the (QML) slideshow were not being loaded correctly.
+   The log is now somewhat more informative when that fails.
+
+## Modules ##
+ - *fstab* can now be configured to put `/tmp` on a *tmpfs*, and this can
+   depend on it being on an SSD or not. Options applicable to `/tmp` can
+   be configured separately as well. #1818 (Thanks Arjen)
+ - *partition* now has some support for re-using LUKS partitions.
+   (Thanks Arjen)
+ - *partition* will cycle out a LUKS key if all the key slots are in use
+   and a new key is added, rather than crashing the installer. (Thanks Arjen)
+ - *welcome* and *welcomeq* have no *About* button anymore; this is now
+   available from the progress panel, since it's also not-really about the
+   distro itself.
+
+
+# 3.2.58.2 (2022-05-24)
+
+This is a extra-quick release for an issue that shows up when using a
+swap **file** on a btrfs filesystem; the installation would fail with
+a Python error, raised from btrfs-progs. Reported by Evan James, Erik
+Dubois, TechXero.
+
+
+# 3.2.58.1 (2022-05-20)
+
+This is a hot-fix release for a regression in the *partition* module where
+it was impossible to proceed unless *Encrypt system* was checked.
+
+
+# 3.2.58 (2022-05-18) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Arjen Balfoort
+ - Enrique Medina Gremaldos
+ - Evan James
+
+## Core ##
+ - Internal improvements to translations-setup means that Catalan (in the
+   Valencian dialect), Occitan (Lenga d'Oc) and Serbian (in Latin script)
+   are all better supported. Thanks Enrique.
+
+## Modules ##
+ - *netinstall* Now displays entries with an empty name slightly differently.
+   An empty name is not generally useful, but in combination with
+   *immutable:true* and *selected:false* can be used to introduce separators
+   or descriptive comments into the list of packages.
+ - *partition* does not offer full-disk encryption when using ZFS. ZFS and the
+   way Calamares sets up FDE don't mix well. (Thanks Evan)
+ - *partition* Various bugs related to LUKS have been fixed. (Thanks Arjen)
+ - *users* module now has a structured *user* key with settings specific
+   to the user (shell, in particular). This maintains backwards compatibility
+   with the *userShell* key.
+ - *users* module now has lists of forbidden login- and host-names, to
+   avoid settings that will mess up the install (e.g. using a login-name
+   that is one of the system's reserved names). #1944
+
+
+# 3.2.57 (2022-05-04) #
+
+This release contains contributions from (alphabetically by first name):
+ - Arjen Balfoort (new contributor! Welcome!)
+ - Victor Fuentes
+
+## Core ##
+ - Calamares can now be started in Serbian (Latin Script) and Catalan
+   (Valencia) when the LANG environment variable is set to values
+   that indicate those languages.
+
+## Modules ##
+ - *fstab* and *luksbootkeyfile* have better support for an **un**encrypted
+   `/boot` partition. #1931 (thanks Arjen)
+ - *packagechooser* and *packagechooserq* can now be given a custom name
+   in the side-panel. #1932 (thanks Victor)
+
+
+# 3.2.56 (2022-04-22) #
+
+As of this release, Calamares 3.2 development is winding down. The
+reason is simple: systems where the backwards-compatibility of Calamares
+3.2 is important are becoming increasingly difficult to work with
+for **other** reasons. Foremost among these are deprecated versions
+of dependencies and tools. Calamares 3.2 branch remains open for
+bugfixes and will see a few more releases, but development is now
+shifting wholesale to the newer generation.
+
+This release contains contributions from (alphabetically by first name):
+ - Victor Fuentes (new contributor! Welcome!)
+
+## Core ##
+ - Changes in git forced some changes on the CI tooling.
+
+## Modules ##
+ - *locale* showed the wrong timezone for Dhaka, although it configured
+   the correct one. #1929
+ - *users* module sets global storage key *fullname* to the full name
+   of the user (e.g. what is entered in the "your full name" box on the
+   users page). #1923 (Thanks Victor)
+
+
+# 3.2.55 (2022-04-11) #
+
+This release contains contributions from (alphabetically by first name):
+ - vtriolet (new contributor! Welcome!)
+
+## Core ##
+ - `readTargetFile()` did not properly return all the lines of the target
+   file. #1918 (thanks vtriolet)
+
+## Modules ##
+ - *users* module has rearranged configuration for setting the hostname.
+   Legacy settings are preserved, but produce a warning. Please see
+   `users.conf` for details.
+ - *users* module has a new hostname.location setting, *Transient*, which
+   will force the installed system to transient-hostname-setting by removing
+   the file `/etc/hostname`.
+ - *users* module has a new hostname.template setting, which allows some
+   tweaking of how the hostname suggestion is constructed. In particular,
+   it can be configured to use the current hostname (whatever that may be).
+   See the example `users.conf` for details on available keys.
+
+
+# 3.2.54 (2022-03-21) #
+
+This release contains contributions from (alphabetically):
+ - Bob van der Linden (new contributor! Welcome!)
+ - El-Wumbus (new contributor! Welcome!)
+ - Evan James
+ - Santosh Mahto (new contributor! Welcome!)
+
+## Core ##
+ - During the installation ("exec") step, while the slideshow is displayed,
+   there is also a button to show the scrolling installation log as it
+   is written. (Thanks Bob)
+
+## Modules ##
+ - *fstab* module correctly handles empty UUID strings. (Thanks Evan)
+ - *partition* module no longer forgets configured partition-layouts.
+   It also respects configured partition labels better. (Thanks Santosh)
+
+
+# 3.2.53 (2022-03-04) #
+
+This release contains contributions from (alphabetically by first name):
+ - Huang Jia Wen (new contributor! Welcome!)
+
+## Core ##
+ - Automount-manipulation (to switch off KDE Plasma automounting new devices)
+   now logs slightly more as it works. Defaults have changed in KDE Plasma
+   5.24 and it turns out the automount-manipulation does not work well.
+   Distro's are encouraged to turn off automount in the live ISO (see #1885).
+
+## Modules ##
+ - *bootloader* now knows about loongarch64 and can install suitable EFI
+   files for this CPU type. (Thanks Huang Jia Wen)
+ - Progress reporting for `pacman` from the *packages* module has been switched
+   off. The progress reporting works under low load, but there are many reports
+   of it crashing (from XeroLinux and from Evan James, who has been debugging
+   the issue) during a regular installation with thousands of updates. This
+   will be revisited in the next release.
+ - The *umount* module was buggy and did not actually unmount anything.
+
+
+# 3.2.52 (2022-02-25) #
+
+This release contains contributions from (alphabetically by first name):
+ - Evan James
+
+## Core ##
+ - No core changes yet
+
+## Modules ##
+ - *fstab* recognizes nvme and mmc devices correctly as SSDs now. #1883
+ - *luksbootkeyfile* handles trailing slashes in mount point
+ - *partition* can be built with a new `SKIP` option, which skips
+   the actual formatting steps but does not fail. The old `LAME`
+   option is renamed `BAIL_OUT`.
+ - *users* has a new key *sudoersConfigureWithGroup* to allow for
+   different styles of sudo configuration. #1887
+
+
+# 3.2.51 (2022-02-01) #
+
+This release contains contributions from (alphabetically by first name):
+ - Evan James
+
+**WARNING** The *umount* module has been rewritten in C++. Check your
+configuration if you previously used the copy-a-log functionality.
+
+## Core ##
+ - Evan has made a start on documenting which Global Storage keys there
+   are and how they tie modules together. This can be found in the
+   `src/modules/README.md` documentation.
+
+## Modules ##
+ - *bootloader* can now be configured to try to generate a unique
+   suffix for the bootloader-id. #1820
+ - *grubcfg* now has a configurable default for kernel parameters,
+   which allows distributions to change the value from `quiet`.
+   The default, if nothing is set, remains `quiet`. Use an explicitly-
+   empty list to specify no-arguments-at-all.
+ - *packagechooser* can now export its choices for use by the *netinstall*
+   module. This makes it possible to use *packagechooser* for large-scale
+   choices, followed by *netinstall* for fine-grained control. (Thanks Evan)
+ - When the *partition* module has a conflicting configuration for the
+   swap choices, it prints a warning and uses the configured choice, rather
+   than always using "suspend". #1881
+ - The *umount* module has been re-written in C++. The copy-a-log-file
+   functionality has been removed. Use the *preservefiles* module for that.
+
+
+# 3.2.50 (2022-01-18) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Erik Dubois
+ - Evan James
+ - Johannes Kamprad
+ - Taejun Park (new contributor, welcome!)
+
+**Replacement notice:** The *umount* module will be replaced by a C++
+implementation in the next release. The "preserve log file" feature
+will be removed in that release. Use the *preservefiles* module instead.
+
+## Core ##
+ - No core changes yet
+
+## Modules ##
+ - *initcpiocfg* mentioned a special kernel-name "all", which did not work,
+   and a special kernel-name "$uname" which cannot work. Fixed the former
+   and removed the "$uname" special key. (Thanks Evan)
+ - *luksswaphookcfg* has been converted to a C++ module.
+ - *networkcfg* could fail to update the NetworkManager configuration
+   if the SSID or username contained non-ASCII characters **and** the
+   default Python text-file encoding was set to ASCII. The files are
+   now read and written in UTF-8, explicitly. #1848
+ - *partition* always sets *bigtime* option on XFS filesystems, if possible.
+   Requires sufficiently-recent xfsprogs. #1874
+ - *preservefiles* was missing some necessary features, needed for it
+   to replace the deprecated log-file-saving functionality in the *umount*
+   module. (Thanks Erik and Joe for testing) #1851
+ - *umount* is now marked as an emergency module in the example configuration,
+   since it should **probably** be run as a cleanup. (Thanks Evan)
+ - *welcome* and *locale* could be confusing, together, and configure
+   the target system with a language that does not match the installer
+   language, even though the user did not make any explicit choice.
+   (Thanks Taejun) #1864
+
+
+# 3.2.49.1 (2021-12-11) #
+
+This is a hot-fix release, to fix a regression in the calculation of
+swap-size. Reported by EndeavourOS (Joe Kamprad) and Xero Linux.
+
+
+# 3.2.49 (2021-12-10) #
+
+This release contains contributions from (alphabetically by first name):
+ - Artem Grinev
+ - Evan James
+
+Distributions are **specifically** reminded to update the *umount* module
+configuration (and to use *preservefiles* if needed).
+
+## Core ##
+ - Errors (e.g. when an installation fails for whatever reason) are displayed
+   in a dialog with a scrollable details panel, rather than growing up
+   to the size of the screen. (Thanks Artem)
+
+## Modules ##
+ - *bootloader* better supports multiple installations of the same OS.
+ - *mount* supports btrfs subvolumes on subdirectories of / now.
+ - *partition* now supports "deep" btrfs subvolume names, e.g. a
+   separate subvolume for `/usr/local`. (Thanks Evan)
+ - The *umount* module now warns if the "preserve log file" feature is used.
+   This has been deprecated for a long time: use the *preservefiles* module
+   instead. A future release will turn this into an error.
+
+
+# 3.2.48 (2021-12-03) #
+
+This release contains contributions from (alphabetically by first name):
+ - Evan James
+
+## Core ##
+ - Python modules now have `warn()` and `error()` methods they can call,
+   alongside the existing `debug()` and `warning()` (all live in the
+   *libcalamares.utils* module).
+ - Python modules can load YAML files via `libcalamares.utils.load_yaml()`.
+   This may be the most useful for test-scripts.
+
+## Modules ##
+ - *fstab* now has a separate, special, flags-setting for swap subvolumes
+   on btrfs. A swap subvolume is created if a swap **file** (not a separate
+   partition) is selected in the auto-partitioning page. (Thanks Evan)
+ - When using btrfs, the *mount* module creates subvolumes. It was not
+   possible to **avoid** having a subvolume name created for the root.
+   This is now possible. #1837
+ - The *packages* module now has some special settings for the `pacman`
+   package manager (generally used on Arch-derivatives). This allows
+   tweaking of the installation process, if downloads are slow or
+   packages may fail to install. See the `packages.conf` file for
+   details. (Thanks Evan)
+
+
+# 3.2.47 (2021-11-19) #
+
+This release contains contributions from (alphabetically by first name):
+ - Evan James
+ - Jonas Strassel
+
+## Core ##
+ - The translation for Sinhala (`si`) has reached 100%. Thank you to
+   හෙළබස and Sandaruwan, translators for Sinhala, for special effort
+   in completing that translation.
+ - Logging now supports Redacted names. This reduces the scope for
+   leaking names or other private information through the logs
+   (if they are posted to a pastebin). A name is redacted consistently
+   within one run of Calamares, but differently each time.
+
+## Modules ##
+ - *bootloader* with systemd-boot now handles root subvolumes better
+   (Thanks Evan)
+ - *displaymanager* supports the *greetd* display manager, which is a
+   kind of meta-DM itself, supporting multiple greeters. (Thanks Jonas)
+ - *finishedq* now has an extra example QML file that builds the UI in
+   a different fashion, demonstrating how a mobile-OS customization of
+   Calamares would present the "all done" message.
+ - *fstab* has an example configuration file that mentioned `space_cache`
+   as an option. Since 2014 there was only one possible value, so this
+   option matched the default-and-only value. Newer kernels with newer
+   btrfs versions have a `v2` option value as well. Remove the example
+   option, since the kernel automatically picks the right value, while
+   setting it to the wrong one may prevent the system from booting.
+   (Thanks Evan)
+ - The *partition* module no longer logs recognizable disk names or
+   UUIDs. These are redacted in the logs. #1593
+ - The *partition* module, together with the new *zfs* module and changes
+   in *mount* and *bootloader* can install to ZFS **if** the distribution
+   kernel supports it. ZFS tools are required, as well as the relevant
+   kernel modules. See the `README.md` in the *zfs* module. (Thanks Evan)
+
+
+# 3.2.46 (2021-11-09) #
+
+This release contains contributions from (alphabetically by first name):
+ - Philip Müller
+
+## Core ##
+ - A new core class `Runner` is now responsible for running commands
+   either in the host or in the target system. This is invisible for
+   end-users, but **does** expand the API available to consumers inside
+   Calamares modules. In particular, Python modules can now easily read
+   and respond to command output. #1740
+
+## Modules ##
+ - *fstab* writes a slightly different message in `/etc/crypttab`
+   about the root filesystem. Since Calamares itself ignores the
+   (previous wording of) message, it was confusing. #1811
+ - *packages* module has some support for reporting progress while
+   the packages are installed. This depends on the package-manager itself
+   reporting useful progress information **and** the *packages* module having
+   support-code to interpret that progress. A proof-of-concept for `pacman`
+   has been implemented. #1582
+ - *partition* has a number of edge-cases for LVM and LUKS resolved. #1564 #1817
+ - *partition* module once again always offers `/boot` as a mount-point, even
+   when EFI would want `/boot/efi`. (Thanks Phil)
+ - *summary* had a regression and showed some descriptive texts twice.
+
+
+# 3.2.45 (2021-10-31) #
+
+This release contains contributions from (alphabetically by first name):
+ - Evan James (new contributor, welcome!)
+
+## Core ##
+ - New internal convenience functions from Evan
+
+## Modules ##
+ - *packagechooser* now displays screenshots nicely-scaled
+   rather than jagged. (#1807)
+ - *partition* module removes ZFS partitions directly. At install-time,
+   we think that the partitions should be handled separately from a
+   zpool that potentially includes those partitions. (Thanks Evan)
+ - *services-systemd* supports timers, e.g. for weekly trim on SSDs.
+   (Thanks Evan)
+
+
+# 3.2.44.3 (2021-10-04) #
+
+This is not a hotfix release, but a tiny-tiny incremental improvement
+that fixes one hugely annoying -- user-facing message presenting
+bytes as mebibytes -- bug in the partition module.
+
+## Modules ##
+ - The *partition* module now consistently uses the configured EFI
+   partition size (defaults to 300MiB).
+ - Internal changes in the *summary* module to increase consistency
+   between *summary* and *summaryq*.
+
+
+# 3.2.44.2 (2021-09-27) #
+
+This release contains contributions from (alphabetically by first name):
+ - Corey Lang (new contributor, welcome!)
+
+This is a hotfix for a typo -- not a syntax error -- that affects the
+*networkcfg* module. Reported and fixed by Corey.
+
+
+# 3.2.44.1 (2021-09-24) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+
+This is a hotfix for a typo -- not a syntax error -- that affects the
+*initcpiocfg* module. Reported and fixed by Anke.
+
+
+# 3.2.44 (2021-09-24) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Shrinivas Vishnu Kumbhar (new contributor, welcome!)
+ - whorfin (new contributor, welcome!)
+
+## Core ##
+ - "Log spam" has been reduced a little in the partitioning module.
+
+## Modules ##
+ - *initcpiocfg* has had a number of internal code-fixes, and now adds
+   the `consolefont` hook by default as well. (Thanks Shrinivas)
+ - Both *locale* and *keyboard* have received some tweaks for configurations
+   in India; unless the user selects otherwise, English is preferred.
+ - The *luksbootkeyfile* module was reported to be too quick to declare
+   a timeout when applying the keyfile. The timeout has been increased
+   to one minute. (Thanks whorfin)
+ - *networkcfg* tries harder to find the live-user login for re-working
+   networking settings. This fixes a regression on FerenOS, where the
+   installer was crashing because it could not find the live-user login.
+
+
+# 3.2.43 (2021-09-17) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Joe Kamprad
+
+## Core ##
+ - Translations have been made more consistent. In particular, some *OK*,
+   *Yes*, *No* and *Cancel* buttons that were previously untranslated
+   or "stuck" in the language that Calamares started in, are now
+   changed to the current language as selected in the welcome page.
+ - Documentation improvements from Joe Kamprad. A *sizeLimit* of zero
+   (which is the default if nothing is set in the branding configuration)
+   disables log uploads.
+
+## Modules ##
+ - The *keyboardq* module (QML-based UI for keyboard-layout-selection)
+   now features an interactive keyboard preview and has the
+   layout adjusted. (Thanks Anke)
+
+
+# 3.2.42 (2021-09-06) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Artem Grinev
+ - Nico 'dr460nf1r3' (new contributor, welcome!)
+ - Waneon Kim (new contributor, welcome!)
+
+## Core ##
+ - No core changes yet
+
+## Modules ##
+ - BTRFS partitions are no longer listed as "check in phase 2" in
+   the *fstab* module. (Thanks Nico)
+ - The *keyboard* module (and *keyboardq*) now pick an English layout
+   (with Rupee) for keyboards when the language is English and locale is India,
+   rather than Hindi layout.
+ - The *localeq* module had the i18n.qml rewritten to make it easier
+   to customize. A bug in the layout has been fixed, and the overall
+   look has been updated.
+ - *networkcfg* now translates the "live user" on an ISO to the regular
+   user on the installed system, so that network configuration changes
+   made in the live system are automatically used after installation. #1755
+ - *partition* no longer allows you to delete an extended partition with
+   children (which led to crashes). #1749 (Thanks Artem)
+ - *partition* complains in more detail about the state of the UEFI
+   boot partition (under manual partitioning schemes). #1761
+ - *welcome* can now check multiple URLs to determine if internet connectivity
+   is available. It is still recommended to check the distro home-page or
+   some special "ping" page of the distro, although that has some privacy
+   implications; using example.com or google.com may work as well. Listing
+   multiple URLs will ping each of them in turn until one succeeds. #1669
+ - The work to make a QML version available for all view modules is almost
+   completed. Two new QML modules have been added *packagechooserq* and *summaryq*.
+   Summaryq brings the option to present the summary page in a customizable
+   way, with a bit more of a contemporary look. Packagechooserq adds the option
+   to preselect an item and displays all options in one overview.
+   (Thanks Anke)
+
+
+# 3.2.41.1 (2021-08-05) #
+
+This is a hotfix release for a crash in the *partition* module, reported on
+KDE neon. #1746
+
+
+# 3.2.41 (2021-07-31) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Camilo Higuita
+
+## Core ##
+ - The (re)translation framework has been internally re-vamped to be
+   less resource-intensive and to work with all QObjects, not just
+   widgets. Consumers of the translations framework are expected to
+   set up the event filter on the top-level widget(s) manually. Since
+   Calamares and the Calamares-test-applications have been adjusted already,
+   no further action is needed.
+
+## Modules ##
+ - When the *keyboard* module is activated, it no longer replaces
+   an explicit user choice (e.g. for a Belgian layout) by a guessed-for-
+   this-language layout (e.g. Danish if you're installing in Danish).
+ - Logic for handling installation lists has been moved around in the
+   *packages* module so that package managers can, in principle,
+   adjust how to handle critical and non-critical package lists.
+ - In the *partition* module, translation code has been simplified.
+ - The *usersq* module has had a fair bit of QML rewritten to make it easier
+   to customize the colors used by the module in a consistent way.
+   (Thanks Anke)
+ - *Welcome* now uses a translated message from the Config object,
+   increasing the sharing between widgets- and QML-modules.
+
+
+# 3.2.40 (2021-07-14) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Anubhav Choudhary (SoK success!)
+ - Emmanuel Arias (new contributor! welcome!)
+ - Erik Dubois
+ - Jerrod Frost (new contributor! welcome!)
+ - Jia Chao (new contributor! welcome!)
+ - Joe Kamprad
+ - Lisa Vitolo (blast from the past!)
+ - Omer I.S. (new contributor! welcome!)
+
+In project news, chat (instant-messaging) communications has largely
+moved to Matrix and Libera.Chat. CI notifications -- issues and build
+results -- are sent to Matrix only.
+
+## Core ##
+ - The CMake modules for consumption by external modules (e.g. the
+   calamares-extensions repository, but also any other modules built
+   by distro's for internal use) now support consistent skip-module
+   behavior and reporting. #1641 (one tiny part of this change)
+ - In global storage, the *filesystem_use* key now has an API in
+   libcalamares to systematically mark filesystem (types) as "in use"
+   or not. This, in turn, means that modules can depend on that information
+   for other work (e.g. removing drivers for unused filesystems). #1635
+ - The "upload log file" now has a configurable log-file-size. (Thanks Anubhav)
+
+## Modules ##
+ - *bootloader* can now install an aarch64 (ARM) compatible EFI GRUB. (Thanks Jia)
+ - *displaymanager* example configuration has been shuffled around a bit,
+   for better results when the live image is running XFCE. Also lists
+   more potential display managers. #1205 (Thanks Erik)
+ - *keyboard* now switches on an alternate `en_US` keyboard layout when
+   Arabic or Hebrew is selected as primary layout. (Thanks Omer)
+ - *localeq* now has a fully functional offline option (alongside the default
+   interactive map option, which requires internet).
+ - The *netinstall* module can now fall back to alternative URLs when
+   loading groups data. The first URL to yield a non-empty groups
+   collection is accepted. No changes are needed in the configuration. #1673
+ - *packagechooser* can now integrate with the *packages* module; that
+   means you can specify package names to install for a given selection,
+   and the regular package-installation mechanism will take care of it.
+   Legacy configurations that use *contextualprocess* are still supported.
+   See the `packagechooser.conf` file for details. #1550
+ - A long-neglected pull request from Lisa Vitolo for the *partition*
+   module -- allowing to set filesystem labels during manual partitioning --
+   has been revived and merged.
+ - The *partition* manager has had a long-standing bug with partition-flags
+   and manual partitioning resolved. This may help resolve some installation
+   issues on UEFI systems. #1724
+ - *usersq* is further implemented and can now be used for a successful install.
+   Not all warning messages available in the regular users module are implemented.
+
+
+# 3.2.39.3 (2021-04-14) #
+
+A minor bugfix tweak release. Since this contains yet **another**
+autologin-related fix, and there is nothing large enough to justify
+a 3.2.40 release yet, add it to the growing tail of 3.2.39. (Reported
+by Joe Kamprad, #1672). Also fixes a regression from 3.2.28 in
+localized packages (e.g. *package-LOCALE* did not work).
+
+
+# 3.2.39.2 (2021-04-02) #
+
+This is **another** hotfix release for issues around autologin ..
+autoLogin, really, since the whole problem is that internal capitalization
+changed. An unrelated bug in writing /etc/default/keyboard was
+also fixed. (Reported by pcrepix, #1668)
+
+
+# 3.2.39.1 (2021-03-30) #
+
+This hotfix release corrects a regression in the *displaymanager*
+module caused by changes in the *users* module; autologin was
+internally renamed and no longer recognized by the *displaymanager*
+module. (Reported by Erik Dubois, #1665)
+
+
+# 3.2.39 (2021-03-19) #
+
+This release contains contributions from (alphabetically by first name):
+ - Matti Hyttinen
+
+## Core ##
+ - A *packages* service has been added to the core, for use by
+   *netinstall* module and any others that need to set up
+   package information for the *packages* module.
+
+## Modules ##
+ - The *mount* module has gained a configurable setup for btrfs volumes.
+   If your distro has a default-to-btrfs setup, it can skip the hard-
+   coded setup (which Calamares has had for a long time with @home
+   and similar) and introduce a custom btrfs configuration through the
+   `mount.conf` file. See issues #1659 and #1661 for warnings about
+   using this in production.
+ - *netinstall* now supports fallbacks for the groups data.
+   Instead of a single URL, multiple URLs may be specified in
+   a list and Calamares goes through them until one is successfully
+   retrieved. Older configurations with a single string are
+   treated like a one-item list. #1579
+ - The *usersq* module now connects to the internal configuration
+   object and may be usable for regular installations.
+
+
+# 3.2.38.1 (2021-03-15) #
+
+This hotfix release is for this item in the release notes of 3.2.38:
+ - The .desktop file for Calamares now makes a longer trip, calling
+   `sh -c "pkexec calamares"`; distributions may still need to adjust.
+The change had been lost while updating other files. It has been restored
+in `calamares.desktop` and `calamares.desktop.in`. (Reported by Erik)
+Other minor changes and fixes:
+ - presets in the *users* module show the hostname, too,
+ - translations update for Korean, Ukranian and Chinese (zh_TW).
+
+
+# 3.2.38 (2021-03-14) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Anubhav Choudhary
+ - Neal Gompa
+
+## Core ##
+ - Uploading your log files (in case of installation failure) has been
+   expanded and is now more configurable. Users should still take care
+   when uploading logs, and distro's should configure a URL with
+   no public viewing of those logs. (Thanks Anubhav)
+ - The .desktop file for Calamares now makes a longer trip, calling
+   `sh -c "pkexec calamares"`; distributions may still need to adjust.
+
+## Modules ##
+ - A new QML-based *finishedq* module has been added. (Thanks Anke)
+ - The *packages* module no longer supports *urpmi*; no Calamares-
+   consumers with that package manager seem to exist. (Thanks Neal)
+ - The *users* module now can set a fixed username and prevent editing.
+   The *presets* configuration entry in `users.conf` can set a *loginName*
+   and a *fullName* and (independently) enable or disable editing of
+   that value. You can, for instance, set *loginName* to "manjaro" if
+   you like; the user can change it afterwards. You could set the
+   *loginName* to "oem" and prevent editing it as well. #942
+
+
+# 3.2.37 (2021-02-23) #
+
+This release contains contributions from (alphabetically by first name):
+ - benne-dee
+
+## Core ##
+ - Calamares has a table of 'best guess' languages for each country
+   and when GeoIP is enabled, it will automatically select that
+   country's language as default -- the user can of course pick
+   a different one. The 'best guess' is based on Unicode / ISO
+   data, which is sometimes dubious. Based on some personal notes,
+   the 'best guess' language for Belarus has been changed to Russian.
+ - Calamares has a table of 'best guess' keyboard mappings,
+   allowing native language input. However, usernames and
+   passwords should be in US-ASCII (this is a limitation of
+   the login system -- **some** parts of the system will support
+   non-ASCII input, but it's better safe than sorry).
+   Add Greek to the list of languages that needs US-ASCII
+   in addition to native input.
+ - The CI infrastructure now builds Calamares and Calamares-extensions
+   on a nightly basis.
+
+## Modules ##
+ - The *netinstall* module has a YAML schema, allowing packagers
+   to validate and verify their netinstall configurations before
+   shipping an ISO (or writing bug reports). Thanks benne-dee.
+ - The *finished* module has been heavily refactored, opening
+   the way to a QML-based version of the same module. This is
+   also preparatory work for allowing packagers (e.g. PostmarketOS)
+   to customize the messages on the finished page.
+
+
+# 3.2.36 (2021-02-03) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anubhav Choudhary
+ - benne-dee
+ - Gaël PORTAY
+ - Jonas Strassel
+ - Kevin Kofler
+ - Matti Hyttinen
+ - Neal Gompa
+
+## Core ##
+ - It is now possible to hide the *next* and *back* buttons during
+   the "exec" phase of installation. Thanks Anubhav.
+ - The Calamares CI has migrated to GitHub actions. Thanks Jonas.
+
+## Modules ##
+ - *bootloader* now uses the current file names for the UEFI Secure Boot
+   shim instead of obsolete ones.
+ - The *mount* module creates swap in its own subvolume, if btrfs is used.
+   Thanks Matti.
+ - *partition* includes more information about what it will do, including
+   GPT partition types (in human-readable format, if possible). Thanks Gaël.
+ - Some edge-cases with overlay filesystems have been resolved in the
+   *partition* module. Thanks Gaël.
+ - During the creation of filesystems and partitions, automounting is
+   turned off (if DBus is available, and the host system supports
+   KDE Solid automount control). This should reduce the number of
+   failed installations if automount grabs partitions while they are
+   being created. The code is prepared to handle other ways to control
+   automount-behavior as well.
+
+
+# 3.2.35.1 (2020-12-07) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anubhav Choudhary
+ - Matti Hyttinen
+
+Some strange string artifacts appeared, leading to `{1?}` being
+displayed in various user-facing messages. These have been removed
+and the translations updated.
+
+## Modules ##
+ - The *initcpiocfg* module would sometimes configure the system to ask
+   for a passphrase, when none is needed.
+
+
 # 3.2.35 (2020-11-30) #
 
 This release contains contributions from (alphabetically by first name):

CHANGES-3.3

@@ -0,0 +1,199 @@
+<!-- SPDX-FileCopyrightText: no
+     SPDX-License-Identifier: CC0-1.0
+-->
+
+This is the changelog for Calamares. For each release, the major changes and
+contributors are listed. Note that Calamares does not have a historical
+changelog -- this log starts with version 3.3.0. See CHANGES-3.2 for
+the history of the 3.2 series (2018-05 - 2022-08).
+
+# 3.3.0-alpha4 (2023-10-13)
+
+Another closing-in-on-3.3.0 release! One of the big changes is that
+Calamares -- the core and nearly all of the modules in this repository --
+are compatible with Qt6. That is, it compiles. Functionality has not
+been tested, but early-testing distributions are encouraged to submit
+pull requests to improve the code.
+
+This release contains contributions from (alphabetically by first name):
+ - Adriaan de Groot
+ - Anke Boersma
+ - Emir Sari
+ - Evan James
+ - Hector Martin
+ - Ivan Borzenkov
+ - Simon Quigley
+
+## Core ##
+ - Qt6 compatibility. You can choose Qt5 (with KDE Frameworks 5) as before,
+   or choose Qt6 (with KDE Frameworks 6). This means that a Qt6-based Linux
+   distribution can use Calamares without needing an extra version of Qt.
+   Note that some KDE Frameworks are required as well, and those need to be
+   Qt6-based also (and are not released as of September 2023).
+ - QML-based modules are also supported in Qt6, but the QML is likely to
+   be source-incompatible. The *welcomeq* module shipped with Calamares
+   now has two `.qrc` files and uses the `${QT_VERSION_SUFFIX}` variable
+   to pick one of the two depending on the Qt version being used.
+   Other modules are likely to follow the same pattern.
+ - C++ namespaces have been shuffled around and `CalamaresUtils` has been
+   retired. This has an effect on all C++ plugins, since this is neither
+   a binary- nor source-compatible change.
+
+## Modules ##
+ - *keyboard* module can now be explicitly configured to use X11 keyboard
+   settings or the FreeDesktop locale1 DBus service. The latter is most
+   useful for Calamares as an "initial setup" system, not an installer,
+   in a Wayland session. (thanks Hector)
+ - *keyboard* module now writes X11 layout configuration with variants
+   for all non-ASCII (e.g. us) layouts. (thanks Ivan)
+ - *keyboard* module now can configure keyboard switch. (thanks Ivan)
+
+
+# 3.3.0-alpha3 (2023-08-28)
+
+This release contains contributions from (alphabetically by first name):
+ - Adriaan de Groot
+ - Aleksey Samoilov
+ - Anke Boersma
+ - Arjen Balfoort
+ - Boria138
+ - Brian Morison
+ - Emir Sari
+ - Evan Goode
+ - Evan James
+ - Ficelloo
+ - Hector Martin
+ - Jeremy Attall
+ - Johannes Kamprad
+ - Kasta Hashemi
+ - Kevin Kofler
+ - Mario Haustein
+ - Masato TOYOSHIMA
+ - Panda
+ - Paolo Dongilli
+ - Peter Jung
+ - Philip Müller
+ - Shivanand
+ - Sławomir Lach
+ - Sunderland93
+ - wiz64
+
+## Core ##
+ - Incompatible module-configuration changes, see #1438.
+ - Branding entries use ${var} instead of @{var} for substitutions,
+   in line with all the other substitution mechanisms used from C++
+   core. See documentation in `branding.desc`.
+ - Boost::Python requires at least version 1.72.
+ - KDE Frameworks must be version 5.58 or later.
+ - The `INSTALL_CONFIG` option has been removed. If you are installing
+   the example configuration files from the Calamares repository, just
+   stop. That was never a good idea, and you should keep your configs elsewhere.
+ - Progress percentage during install can now be localized. (thanks Emir)
+
+## Modules ##
+ - *dracut* added a configurable kernel name. (thanks Anke)
+ - *initcpiocfg* orders hookds slightly differently. (thanks Peter)
+ - *localeq* moved to using Drawer instead of ComboBox in UI. (thanks Anke)
+ - *keyboardq* moved to using Drawer instead of ComboBox in UI. (thanks Anke)
+ - *netinstall* now has a new *noncheckable* option for groups, which prevent
+   it a group from being checked/uncheckd as a whole. You can still check
+   individual items **in** the group though. (thanks Shivanand)
+ - *partition* can now pick LUKS or LUKS2. (thanks Jeremy)
+ - *zfs* creates a hostid through zgenhostid.
+ - *zfshostid* new module to copy zfs generated /etc/hostid
+
+
+# 3.3.0-alpha2 (2022-08-23)
+
+Second alpha release, with updated ABI compatibility checking,
+some 3.3.0 release goals, new features in modules and important bugfixes.
+
+This release contains contributions from (alphabetically by first name):
+ - Adriaan de Groot
+ - Anke Boersma
+ - Evan James
+ - Shivanand
+ - Vitor Lopes
+
+## Core ##
+
+A core **TODO** is moving all library code into the `Calamares` namespace,
+dropping the `CalamaresUtils` namespace. Modern C++ supports nested namespaces,
+so in some cases we can use those. This has a drastic effect on ABI compatibility,
+though, as functions move from one namespace to another. This needs to be
+completed before a 3.3.0 with ABI stability is released.
+
+## Modules ##
+
+Module schemas have been updated to reflect all the incompatible changes.
+
+
+# 3.3.0-alpha1 (2022-06-27)
+
+Initial 3.3.0 alpha release to check the release scripts &c.
+
+This release contains contributions from (alphabetically by first name):
+ - Adriaan de Groot
+ - Aleksey Samoilov
+ - Anke Boersma
+ - Dan Simmons
+ - Evan James
+ - Peter Jung
+
+
+# 3.3.0-pre-alpha (unreleased) #
+
+This release contains contributions from (alphabetically by first name):
+ - Anke Boersma
+ - Anubhav Choudhary
+ - Evan James
+ - Vitor Lopes
+
+This is a "minor" version change, but the size of the changes is very
+large. Configuration files from previous versions of Calamares will
+**certainly** need to be re-validated. Take heed of the many changes
+in the *Modules* heading, below.
+
+Users (distributions) are **strongly** advised to use the tools
+for configuration validation (`ci/configvalidator.py`) to check
+that the distribution configuration files follow the current schema.
+
+## Project ##
+ - The C++ code in the project is now formatted with clang-format 12 or 13,
+   with the coding-style as found in `.clang-format`; there are minor
+   differences from the tool, compared to the clang-format 9 usually applied
+   to Calamares 3.2.
+ - The CMake code in the project is now formatted with gersemi 0.7.5.
+
+## Core ##
+ - CMake 3.16, Qt 5.15 are now required; the newer CMake is to support
+   new features (also for KDE Frameworks), Qt is the current LTS version.
+ - Running `calamares -d` no longer enforces a single-application
+   (it is for debugging purposes, after all).
+ - Python 3.6 or later is now required, to allow for F-strings in
+   Python code and allow other tidy-ups in the Python modules.
+   Boost::Python now requires 1.67 or later (for CMake support).
+ - The log file now **always** contains a debug-log, and the `-D` flag
+   primarily controls what is printed to stdout. By default, stdout
+   only gets errors; use `-D6` to match stdout with the file. Use `-D8`
+   to get an extra-verbose log file **and** verbose stdout.
+
+## Modules ##
+ - *bootloader* now supports more options when building the kernel
+   command-line. (Thanks Evan)
+ - *bootloader* no longer supports `@@`-style suffixes for unique-EFI-id
+   generation. Use `${}` instead.
+ - *displaymanager* no longer supports the discontinued *kdm* display manager.
+ - *fstab* configuration has been completely re-done. Many configuration
+   options have moved to the *mount* module. See #1993
+ - *grubcfg* changed the key *keepDistributor* to *keep_distributor*.
+   Please update configurations.
+ - *mount* now does most of the mounting; options that were in *fstab*
+   have moved here. See #1993
+ - *oemid* now uses consistent variable replacement (e.g. KMacroExpander)
+   and does not support `@@DATE@@` anymore (use `${DATE}`).
+ - *partition* requires KPMCore 21.12 (e.g. KPMCore 4.2 API, or later).
+ - *partition* can now skip installing the bootloader in more scenarios.
+   #1632 (Thanks Anubhav)
+ - *preservefiles* follows `${}` variable syntax instead of `@@`.
+

CMakeLists.txt

@@ -19,50 +19,75 @@
 #
 #   SKIP_MODULES    : a space or semicolon-separated list of directory names
 #                     under src/modules that should not be built.
-#   USE_<foo>       : fills in SKIP_MODULES for modules called <foo>-<something>
+#   USE_<foo>       : fills in SKIP_MODULES for modules called <foo>-<something>.
 #   WITH_<foo>      : try to enable <foo> (these usually default to ON). For
 #                     a list of WITH_<foo> grep CMakeCache.txt after running
 #                     CMake once. These affect the ABI offered by Calamares.
 #                       - PYTHON (enable Python Job modules)
 #                       - QML (enable QML UI View modules)
-#                       - PYTHONQT # TODO:3.3: remove
+#                       - QT6 (use Qt6 rather than Qt5, default to OFF)
+#                     The WITH_* options affect the ABI of Calamares: you must
+#                     build (C++) modules for Calamares with the same WITH_*
+#                     settings, or they may not load at all.
 #   BUILD_<foo>     : choose additional things to build
-#                       - TESTING (standard CMake option)
+#                       - APPDATA (use AppData in packagechooser, requires QtXml)
+#                       - APPSTREAM (use AppStream in packagechooser, requires libappstream-qt)
+#                       - BUILD_CRASH_REPORTING (uses KCrash, rather than Calamares internal, for crash reporting)
 #                       - SCHEMA_TESTING (requires Python, see ci/configvalidator.py)
-#   DEBUG_<foo>     : special developer flags for debugging
+#                       - TESTING (standard CMake option)
+#   DEBUG_<foo>     : special developer flags for debugging.
 #
 # Example usage:
 #
 #   cmake . -DSKIP_MODULES="partition luksbootkeycfg"
 #
-# One special target is "show-version", which can be built
-# to obtain the version number from here.
+# To obtain the version number of calamares, run CMake in script mode, e.g.
+#   cmake -P CMakeLists.txt
 
-# TODO:3.3: Require CMake 3.12
-cmake_minimum_required( VERSION 3.3 FATAL_ERROR )
-project( CALAMARES
-    VERSION 3.2.35
-    LANGUAGES C CXX )
+cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
-set( CALAMARES_VERSION_RC 0 )  # Set to 0 during release cycle, 1 during development
+set(CALAMARES_VERSION 3.3.0-alpha4)
+set(CALAMARES_RELEASE_MODE ON) # Set to ON during a release
+
+if(CMAKE_SCRIPT_MODE_FILE)
+    include(${CMAKE_CURRENT_LIST_DIR}/CMakeModules/ExtendedVersion.cmake)
+    set(CMAKE_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR})
+    extend_version( ${CALAMARES_VERSION} ${CALAMARES_RELEASE_MODE}  _vshort _vlong )
+    message("${_vlong}")
+    return()
+endif()
+
+# Massage the version for CMake if there is a version-suffix
+string(REGEX REPLACE "-.*" "" CALAMARES_VERSION_SHORT "${CALAMARES_VERSION}")
+# And preserve the original version (suffix and all) because project() overwrites
+# .. but if we're doing non-release builds, this gets replaced with git versioning.
+set(CALAMARES_VERSION_LONG "${CALAMARES_VERSION}")
+
+project(CALAMARES VERSION ${CALAMARES_VERSION_SHORT} LANGUAGES C CXX HOMEPAGE_URL "https://calamares.io/")
+
+if(NOT CALAMARES_RELEASE_MODE AND CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
+    message(FATAL_ERROR "Do not build development versions in the source-directory.")
+endif()
+# Calamares in the 3.3 series promises ABI compatbility, so it sets a
+# .so-version equal to the series number. We use ci/abicheck.sh to
+# keep track of this. Note that the **alpha** releases also have
+# such an .so-version, but are not ABI-stable yet.
+set(CALAMARES_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
 ### OPTIONS
 #
-option( INSTALL_CONFIG "Install configuration files" OFF )
-option( INSTALL_POLKIT "Install Polkit configuration" ON )
-option( INSTALL_COMPLETION "Install shell completions" OFF )
-# Options for the calamares executable
-option( WITH_KF5Crash "Enable crash reporting with KCrash." ON )  # TODO:3.3: WITH->BUILD (this isn't an ABI thing)
-option( WITH_KF5DBus "Use DBus service for unique-application." OFF )  # TODO:3.3: WITH->BUILD
+option(INSTALL_POLKIT "Install Polkit configuration" ON)
+option(INSTALL_COMPLETION "Install shell completions" OFF)
 # When adding WITH_* that affects the ABI offered by libcalamares,
 # also update libcalamares/CalamaresConfig.h.in
-option( WITH_PYTHON "Enable Python modules API (requires Boost.Python)." ON )
-option( WITH_PYTHONQT "Enable Python view modules API (deprecated, requires PythonQt)." OFF )  # TODO:3.3: remove
-option( WITH_QML "Enable QML UI options." ON )
+option(WITH_PYTHON "Enable Python modules API (requires Boost.Python)." ON)
+option(WITH_QML "Enable QML UI options." ON)
+option(WITH_QT6 "Use Qt6 instead of Qt5" OFF)
 #
-# Additional parts to build
-option( BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON )
-
+# Additional parts to build that do not affect ABI
+option(BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON)
+# Options for the calamares executable
+option(BUILD_CRASH_REPORTING "Enable crash reporting with KCrash." ON)
 
 # Possible debugging flags are:
 #  - DEBUG_TIMEZONES draws latitude and longitude lines on the timezone
@@ -71,8 +96,7 @@ option( BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON )
 #  - DEBUG_FILESYSTEMS does extra logging and checking when looking at
 #    partition configuration. Lists known KPMCore FS types.
 #  - DEBUG_PARTITION_UNSAFE (see partition/CMakeLists.txt)
-#  - DEBUG_PARTITION_LAME (see partition/CMakeLists.txt)
-
+#  - DEBUG_PARTITION_BAIL_OUT (see partition/CMakeLists.txt)
 
 ### USE_*
 #
@@ -91,30 +115,20 @@ option( BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON )
 #
 # To explicitly disable a set of modules, set USE_<foo>=none
 # (e.g. the literal string none), which won't match any of the
-# modules but is handled specially. This is the default for
-# USE_os, which are modules for specialty non-Linux distributions.
+# modules but is handled specially.
 #
 # The following USE_* functionalities are available:
 #  - *services* picks one of the two service-configuration modules,
 #    for either systemd or openrc. This defaults to empty so that
 #    **both** modules are available.
-#  - *os* picks an OS-specific module for things-that-are-not-Linux.
-#    It is generally discouraged to use this unless your distro is
-#    completely unable to use standard Linux tools for configuration.
-#    This defaults to *none* so that nothing gets picked up and nothing
-#    is packaged -- you must explicitly set it to empty to get all of
-#    the modules, but that hardly makes sense. Note, too that there
-#    are currently no os-* modules shipped with Calamares.
-set( USE_services "" CACHE STRING "Select the services module to use" )
-set( USE_os "none" CACHE STRING "Select the OS-specific module to include" )
+set(USE_services "" CACHE STRING "Select the services module to use")
 
 ### Calamares application info
 #
-set( CALAMARES_ORGANIZATION_NAME "Calamares" )
-set( CALAMARES_ORGANIZATION_DOMAIN "github.com/calamares" )
-set( CALAMARES_APPLICATION_NAME  "Calamares" )
-set( CALAMARES_DESCRIPTION_SUMMARY
-    "The distribution-independent installer framework" )
+set(CALAMARES_ORGANIZATION_NAME "Calamares")
+set(CALAMARES_ORGANIZATION_DOMAIN "github.com/calamares")
+set(CALAMARES_APPLICATION_NAME "Calamares")
+set(CALAMARES_DESCRIPTION_SUMMARY "The distribution-independent installer framework")
 
 ### Transifex (languages) info
 #
@@ -125,55 +139,77 @@ set( CALAMARES_DESCRIPTION_SUMMARY
 #
 # Language en (source language) is added later. It isn't listed in
 # Transifex either. Get the list of languages and their status
-# from https://transifex.com/calamares/calamares/ , or (preferably)
+# from https://app.transifex.com/calamares/calamares/ , or (preferably)
 # use ci/txstats.py to automatically check.
 #
 # When adding a new language, take care that it is properly loaded
 # by the translation framework. Languages with alternate scripts
-# (sr@latin in particular) may need special handling in CalamaresUtils.cpp.
+# (sr@latin in particular) or location (ca@valencia) need special
+# handling in libcalamares/locale/Translation.h .
 #
-# TODO: drop the es_ES translation from Transifex
-#
-# NOTE: move eo (Esperanto) to _ok once Qt can actually create a
-#       locale for it. (Qt 5.12.2 can, see Translation Status section).
 # NOTE: move ie (Interlingue) to _ok once Qt supports it.
 # NOTE: update these lines by running `txstats.py`, or for full automation
 #       `txstats.py -e`. See also
 #
-# Total 71 languages
-set( _tx_complete az ca fi_FI fur he hr ja lt sq uk zh_CN zh_TW )
-set( _tx_good as ast az_AZ be cs_CZ da de es fa fr hi hu it_IT ko
-    ml nl pt_BR pt_PT ru sk sv tg tr_TR vi )
-set( _tx_ok ar bg bn el en_GB es_MX es_PR et eu gl id is mr nb pl
-    ro sl sr sr@latin th )
-set( _tx_incomplete ca@valencia eo fr_CH gu ie kk kn lo lv mk ne_NP
-    te ur uz )
+# Total 75 languages
+set( _tx_complete az az_AZ ca fi_FI fr he hr ja ko lt pt_BR pt_PT
+    sv tr_TR uk zh_TW )
+set( _tx_good as be ca@valencia cs_CZ da de es fa fur hi it_IT ml
+    nl ru si sk sq tg vi zh_CN )
+set( _tx_ok ar ast bg bn el en_GB es_MX et eu gl hu id is mr nb oc
+    pl ro sl sr sr@latin th )
+set( _tx_incomplete eo es_PR gu ie ja-Hira kk kn lo lv mk ne_NP
+    ta_IN te ur uz zh zh_HK )
+# Total 75 languages
 
 ### Required versions
 #
 # See DEPENDENCIES section below.
-set( QT_VERSION 5.9.0 )
-set( YAMLCPP_VERSION 0.5.1 )
-set( ECM_VERSION 5.18 )
-set( PYTHONLIBS_VERSION 3.3 )
-set( BOOSTPYTHON_VERSION 1.55.0 )
+if(WITH_QT6)
+    message(STATUS "Building Calamares with Qt6")
+    set(qtname "Qt6")
+    set(kfname "KF6")
+    set(QT_VERSION 6.5.0)
+    set(ECM_VERSION 5.240)
+    set(KF_VERSION 5.240) # KDE Neon weirdness
+    # API that was deprecated before Qt 5.15 causes a compile error
+    add_compile_definitions(QT_DISABLE_DEPRECATED_BEFORE=0x060400)
+    # Something to add to filenames for this specific Qt version
+    set(QT_VERSION_SUFFIX "-qt6")
+else()
+    message(STATUS "Building Calamares with Qt5")
+    set(qtname "Qt5")
+    set(kfname "KF5")
+    set(QT_VERSION 5.15.0)
+    set(ECM_VERSION 5.78)
+    set(KF_VERSION 5.78)
+    # API that was deprecated before Qt 5.15 causes a compile error
+    add_compile_definitions(QT_DISABLE_DEPRECATED_BEFORE=0x050f00)
+    # Something to add to filenames for this specific Qt version
+    set(QT_VERSION_SUFFIX "")
+endif()
 
+set(BOOSTPYTHON_VERSION 1.72.0)
+set(PYTHONLIBS_VERSION 3.6)
+set(YAMLCPP_VERSION 0.5.1)
 
 ### CMAKE SETUP
 #
-set( CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules" )
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/CMakeModules")
 
 # Enable IN_LIST
-if( POLICY CMP0057 )
-    cmake_policy( SET CMP0057 NEW )
+if(POLICY CMP0057)
+    cmake_policy(SET CMP0057 NEW)
 endif()
 # Let ``AUTOMOC`` and ``AUTOUIC`` process ``GENERATED`` files.
-if( POLICY CMP0071 )
-    cmake_policy( SET CMP0071 NEW )
+if(POLICY CMP0071)
+    cmake_policy(SET CMP0071 NEW)
 endif()
 # Recognize more macros to trigger automoc
 if(NOT CMAKE_VERSION VERSION_LESS "3.10.0")
-    list(APPEND CMAKE_AUTOMOC_MACRO_NAMES
+    list(
+        APPEND
+        CMAKE_AUTOMOC_MACRO_NAMES
         "K_PLUGIN_FACTORY_WITH_JSON"
         "K_EXPORT_PLASMA_DATAENGINE_WITH_JSON"
         "K_EXPORT_PLASMA_RUNNER"
@@ -181,40 +217,50 @@ if(NOT CMAKE_VERSION VERSION_LESS "3.10.0")
 endif()
 
 # CMake Modules
-include( CMakePackageConfigHelpers )
-include( CTest )
-include( FeatureSummary )
+include(CMakePackageConfigHelpers)
+include(CTest)
+include(FeatureSummary)
 
 # Calamares Modules
-include( CMakeColors )
+include(CMakeColors)
 
 ### C++ SETUP
 #
-set( CMAKE_CXX_STANDARD 17 )
-set( CMAKE_CXX_STANDARD_REQUIRED ON )
-set( CMAKE_CXX_FLAGS                "${CMAKE_CXX_FLAGS} -Wall -Werror=return-type" )
-set( CMAKE_CXX_FLAGS_DEBUG          "-g ${CMAKE_CXX_FLAGS_DEBUG}" )
-set( CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG" )
-set( CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG" )
-set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g" )
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror=return-type")
+set(CMAKE_CXX_FLAGS_DEBUG "-Og -g ${CMAKE_CXX_FLAGS_DEBUG}")
+set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
-set( CMAKE_C_STANDARD 99 )
-set( CMAKE_C_STANDARD_REQUIRED ON )
-set( CMAKE_C_FLAGS                  "${CMAKE_C_FLAGS} -Wall" )
-set( CMAKE_C_FLAGS_DEBUG            "-g" )
-set( CMAKE_C_FLAGS_MINSIZEREL       "-Os -DNDEBUG" )
-set( CMAKE_C_FLAGS_RELEASE          "-O4 -DNDEBUG" )
-set( CMAKE_C_FLAGS_RELWITHDEBINFO   "-O2 -g" )
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
+set(CMAKE_C_FLAGS_DEBUG "-Og -g")
+set(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG")
+set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")
 
-set( CMAKE_SHARED_LINKER_FLAGS      "-Wl,--no-undefined -Wl,--fatal-warnings" )
+set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined -Wl,--fatal-warnings ${CMAKE_SHARED_LINKER_FLAGS}")
 
-if( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
-    message( STATUS "Found Clang ${CMAKE_CXX_COMPILER_VERSION}, setting up Clang-specific compiler flags." )
+# If no build type is set, pick a reasonable one
+if(NOT CMAKE_BUILD_TYPE)
+    if(CALAMARES_RELEASE_MODE)
+        set(CMAKE_BUILD_TYPE "RelWithDebInfo")
+    else()
+        set(CMAKE_BUILD_TYPE "Debug")
+    endif()
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(STATUS "Found Clang ${CMAKE_CXX_COMPILER_VERSION}, setting up Clang-specific compiler flags.")
 
     # Clang warnings: doing *everything* is counter-productive, since it warns
     # about things which we can't fix (e.g. C++98 incompatibilities, but
     # Calamares is C++17).
-    foreach( CLANG_WARNINGS
+    foreach(
+        CLANG_WARNINGS
         -Weverything
         -Wno-c++98-compat
         -Wno-c++98-compat-pedantic
@@ -226,222 +272,234 @@ if( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
         -Wno-documentation-unknown-command
         -Wno-unknown-warning-option
     )
-        string( APPEND CMAKE_CXX_FLAGS " ${CLANG_WARNINGS}" )
+        string(APPEND CMAKE_CXX_FLAGS " ${CLANG_WARNINGS}")
     endforeach()
 
+    # The dwarf-debugging flags are slightly different, too
+    string(APPEND CMAKE_CXX_FLAGS_DEBUG " -gdwarf")
+    string(APPEND CMAKE_C_FLAGS_DEBUG " -gdwarf")
+
     # Third-party code where we don't care so much about compiler warnings
     # (because it's uncomfortable to patch) get different flags; use
     #       mark_thirdparty_code( <file> [<file>...] )
     # to switch off warnings for those sources.
-    set( SUPPRESS_3RDPARTY_WARNINGS "-Wno-everything" )
+    set(SUPPRESS_3RDPARTY_WARNINGS "-Wno-everything")
 
-    set( CMAKE_TOOLCHAIN_PREFIX "llvm-" )
+    set(CMAKE_TOOLCHAIN_PREFIX "llvm-")
 
     # The path prefix is only relevant for CMake 3.16 and later, fixes #1286
-    set( CMAKE_AUTOMOC_PATH_PREFIX OFF )
-    set( CALAMARES_AUTOMOC_OPTIONS "-butils/moc-warnings.h" )
-    set( CALAMARES_AUTOUIC_OPTIONS --include utils/moc-warnings.h )
+    set(CMAKE_AUTOMOC_PATH_PREFIX OFF)
+    set(CALAMARES_AUTOMOC_OPTIONS "-butils/moc-warnings.h")
+    set(CALAMARES_AUTOUIC_OPTIONS --include utils/moc-warnings.h)
 else()
-    set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Woverloaded-virtual" )
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Woverloaded-virtual")
 
-    set( SUPPRESS_3RDPARTY_WARNINGS "" )
+    set(SUPPRESS_3RDPARTY_WARNINGS "")
 endif()
 
 # Use mark_thirdparty_code() to reduce warnings from the compiler
 # on code that we're not going to fix. Call this with a list of files.
 macro(mark_thirdparty_code)
-    set_source_files_properties( ${ARGV}
-        PROPERTIES
-            COMPILE_FLAGS "${SUPPRESS_3RDPARTY_WARNINGS}"
-            COMPILE_DEFINITIONS "THIRDPARTY"
+    set_source_files_properties(
+        ${ARGV}
+        PROPERTIES COMPILE_FLAGS "${SUPPRESS_3RDPARTY_WARNINGS}" COMPILE_DEFINITIONS "THIRDPARTY"
     )
 endmacro()
 
-if( CMAKE_COMPILER_IS_GNUCXX )
-    if( CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9 OR
-        CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 4.9 )
-        message( STATUS "Found GNU g++ ${CMAKE_CXX_COMPILER_VERSION}, enabling colorized error messages." )
-        set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=auto" )
+if(CMAKE_COMPILER_IS_GNUCXX)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 4.9)
+        message(STATUS "Found GNU g++ ${CMAKE_CXX_COMPILER_VERSION}, enabling colorized error messages.")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=auto")
     endif()
 endif()
 
-
 ### DEPENDENCIES
 #
-find_package( Qt5 ${QT_VERSION} CONFIG REQUIRED Concurrent Core Gui LinguistTools Network Svg Widgets )
-if( WITH_QML )
-    find_package( Qt5 ${QT_VERSION} CONFIG REQUIRED Quick QuickWidgets )
+find_package(${qtname} ${QT_VERSION} CONFIG REQUIRED Concurrent Core DBus Gui LinguistTools Network Svg Widgets)
+if(WITH_QML)
+    find_package(${qtname} ${QT_VERSION} CONFIG REQUIRED Quick QuickWidgets)
 endif()
-# Optional Qt parts
-find_package( Qt5DBus CONFIG )
+# Note that some modules need more Qt modules, optionally.
 
-find_package( YAMLCPP ${YAMLCPP_VERSION} REQUIRED )
-if( INSTALL_POLKIT )
-    find_package( PolkitQt5-1 REQUIRED )
-else()
-    # Find it anyway, for dependencies-reporting
-    find_package( PolkitQt5-1 )
+find_package(YAMLCPP ${YAMLCPP_VERSION})
+set_package_properties(
+    YAMLCPP
+    PROPERTIES
+    TYPE REQUIRED
+    DESCRIPTION "YAML parser for C++"
+    PURPOSE "Parsing of configuration files"
+)
+
+find_package(Polkit${qtname}-1)
+if(INSTALL_POLKIT)
+    set_package_properties(
+        Polkit${qtname}-1
+        PROPERTIES
+        TYPE REQUIRED
+    )
 endif()
 set_package_properties(
-    PolkitQt5-1 PROPERTIES
-    DESCRIPTION "Qt5 support for Polkit"
+    Polkit${qtname}-1
+    PROPERTIES
+    DESCRIPTION "${qtname} support for Polkit"
     URL "https://cgit.kde.org/polkit-qt-1.git"
-    PURPOSE "PolkitQt5-1 helps with installing Polkit configuration"
+    PURPOSE "Polkit${qtname}-1 helps with installing Polkit configuration"
 )
 
 # Find ECM once, and add it to the module search path; Calamares
 # modules that need ECM can do
-#   find_package(ECM ${ECM_VERSION} REQUIRED NO_MODULE),
+#   if(ECM_FOUND)
 # no need to mess with the module path after.
 find_package(ECM ${ECM_VERSION} NO_MODULE)
-if( ECM_FOUND )
+if(ECM_FOUND)
+    message(STATUS "Found KDE ECM ${ECM_MODULE_PATH}")
     set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_MODULE_PATH})
-    if ( BUILD_TESTING )
+    if(BUILD_TESTING)
         # ECM implies that we can build the tests, too
-        find_package( Qt5 COMPONENTS Test REQUIRED )
-        include( ECMAddTests )
+        find_package(${qtname} COMPONENTS Test REQUIRED)
+        include(ECMAddTests)
     endif()
     include(KDEInstallDirs)
 endif()
 
-find_package( KF5 QUIET COMPONENTS CoreAddons Crash DBusAddons )
+find_package(${kfname}CoreAddons ${KF_VERSION} QUIET)
 set_package_properties(
-    KF5::CoreAddons PROPERTIES
+    ${kfname}CoreAddons
+    PROPERTIES
     TYPE REQUIRED
-    DESCRIPTION "Classes built on QtCore for About Data"
-    URL "https://api.kde.org/frameworks/kcoreaddons/"
-    PURPOSE "About Calamares"
+    DESCRIPTION "KDE Framework CoreAddons"
+    URL "https://api.kde.org/frameworks/"
+    PURPOSE "Essential Framework for AboutData and Macros"
 )
-if( NOT KF5Crash_FOUND )
-    if( WITH_KF5Crash )
-        message(WARNING "WITH_KF5Crash is set, but KF5::Crash is not available.")
-    endif()
-    set( WITH_KF5Crash OFF )
-endif()
-if( NOT KF5DBusAddons_FOUND )
-    if( WITH_KF5DBus )
-        message(WARNING "WITH_KF5DBus is set, but KF5::DBusAddons is not available.")
-    endif()
-    set( WITH_KF5DBus OFF )
-endif()
 
-# TODO:3.3: Use FindPython3 instead
-find_package( PythonInterp ${PYTHONLIBS_VERSION} )
+# After this point, there should be no REQUIRED find_packages,
+# since we want tidy reporting of optional dependencies.
+feature_summary(
+    WHAT REQUIRED_PACKAGES_NOT_FOUND
+    FATAL_ON_MISSING_REQUIRED_PACKAGES
+    DESCRIPTION "The following REQUIRED packages were not found:"
+    QUIET_ON_EMPTY
+)
+
+#
+# OPTIONAL DEPENDENCIES
+#
+# First, set KF back to optional so that any missing components don't trip us up.
+find_package(${kfname}Crash ${KF_VERSION} QUIET)
 set_package_properties(
-    PythonInterp PROPERTIES
-    DESCRIPTION "Python 3 interpreter."
-    URL "https://python.org"
-    PURPOSE "Python 3 interpreter for certain tests."
+    ${kfname}Crash
+    PROPERTIES
+    TYPE OPTIONAL
+    DESCRIPTION "KDE Framework Crash"
+    URL "https://api.kde.org/frameworks/"
+    PURPOSE "Framework for sending Crash Dumps"
 )
 
-set( _schema_explanation "" )
-if ( PYTHONINTERP_FOUND )
-    if ( BUILD_SCHEMA_TESTING )
+if(NOT TARGET ${kfname}::Crash)
+    if(BUILD_CRASH_REPORTING)
+        message(WARNING "BUILD_CRASH_REPORTING is set, but ${kfname}::Crash is not available.")
+    endif()
+    set(BUILD_CRASH_REPORTING OFF)
+endif()
+
+find_package(Python ${PYTHONLIBS_VERSION} COMPONENTS Interpreter Development)
+set_package_properties(
+    Python
+    PROPERTIES
+    DESCRIPTION "Python3 interpreter."
+    URL "https://python.org"
+    PURPOSE "Python3 interpreter for certain tests."
+)
+
+set(_schema_explanation "")
+if(Python_Interpreter_FOUND)
+    if(BUILD_SCHEMA_TESTING)
         # The configuration validator script has some dependencies,
         # and if they are not installed, don't run. If errors out
         # with exit(1) on missing dependencies.
-        if ( CALAMARES_CONFIGVALIDATOR_CHECKED )
-            set( _validator_deps ${CALAMARES_CONFIGVALIDATOR_RESULT} )
+        if(CALAMARES_CONFIGVALIDATOR_CHECKED)
+            set(_validator_deps ${CALAMARES_CONFIGVALIDATOR_RESULT})
         else()
-            exec_program( ${PYTHON_EXECUTABLE} ARGS "${CMAKE_SOURCE_DIR}/ci/configvalidator.py" -x RETURN_VALUE _validator_deps )
-            set( CALAMARES_CONFIGVALIDATOR_CHECKED TRUE CACHE INTERNAL "Dependencies for configvalidator checked" )
-            set( CALAMARES_CONFIGVALIDATOR_RESULT ${_validator_deps} CACHE INTERNAL "Result of configvalidator dependency check" )
+            exec_program(
+                ${Python_EXECUTABLE}
+                ARGS
+                "${CMAKE_SOURCE_DIR}/ci/configvalidator.py"
+                -x
+                RETURN_VALUE
+                _validator_deps
+            )
+            set(CALAMARES_CONFIGVALIDATOR_CHECKED TRUE CACHE INTERNAL "Dependencies for configvalidator checked")
+            set(CALAMARES_CONFIGVALIDATOR_RESULT ${_validator_deps}
+                CACHE INTERNAL "Result of configvalidator dependency check"
+            )
         endif()
         # It should never succeed, but only returns 1 when the imports fail
-        if ( _validator_deps EQUAL 1 )
-            set( _schema_explanation " Missing dependencies for configvalidator.py." )
-            set( BUILD_SCHEMA_TESTING OFF )
+        if(_validator_deps EQUAL 1)
+            set(_schema_explanation " Missing dependencies for configvalidator.py.")
+            set(BUILD_SCHEMA_TESTING OFF)
         endif()
     endif()
 else()
     # Can't run schema tests without Python3.
-    set( _schema_explanation " Missing Python3." )
-    set( BUILD_SCHEMA_TESTING OFF )
+    set(_schema_explanation " Missing Python3.")
+    set(BUILD_SCHEMA_TESTING OFF)
 endif()
-add_feature_info( yaml-schema BUILD_SCHEMA_TESTING "Validate YAML (config files) with schema.${_schema_explanation}" )
+add_feature_info(yaml-schema BUILD_SCHEMA_TESTING "Validate YAML (config files) with schema.${_schema_explanation}")
 
-find_package( PythonLibs ${PYTHONLIBS_VERSION} )
-set_package_properties(
-    PythonLibs PROPERTIES
-    DESCRIPTION "C interface libraries for the Python 3 interpreter."
-    URL "https://python.org"
-    PURPOSE "Python 3 is used for Python job modules."
-)
-
-if ( PYTHONLIBS_FOUND )
-    # TODO:3.3: Require Boost + CMake; sort out Boost::Python
-    # Since Boost provides CMake config files (starting with Boost 1.70.
-    # or so) the mess that is the Calamares find code picks the wrong
-    # bits. Suppress those CMake config files, as suggested by @jmrcpn
-    set(Boost_NO_BOOST_CMAKE ON)
-    include( BoostPython3 )
-    find_boost_python3( ${BOOSTPYTHON_VERSION} ${PYTHONLIBS_VERSION_STRING} CALAMARES_BOOST_PYTHON3_FOUND )
-    set_package_properties(
-        Boost PROPERTIES
-        PURPOSE "Boost.Python is used for Python job modules."
-    )
-    # TODO:3.3: Remove PythonQt support
-    find_package( PythonQt )
-    set_package_properties( PythonQt PROPERTIES
-        DESCRIPTION "A Python embedding solution for Qt applications."
-        URL "http://pythonqt.sourceforge.net"
-        PURPOSE "PythonQt is used for Python view modules."
-    )
+if(Python_Development_FOUND)
+    find_package(boost_python)
+    if(NOT TARGET Boost::python)
+        find_package(Boost ${BOOSTPYTHON_VERSION} COMPONENTS python)
+        set_package_properties(Boost PROPERTIES PURPOSE "Boost.Python is used for Python job modules.")
+    else()
+        message(STATUS "Found boost_python with target Boost::python")
+        set(Boost_FOUND ON)
+    endif()
 endif()
 
-if( NOT PYTHONLIBS_FOUND OR NOT CALAMARES_BOOST_PYTHON3_FOUND )
+if(NOT Python_Development_FOUND OR NOT Boost_FOUND)
     message(STATUS "Disabling Boost::Python modules")
-    set( WITH_PYTHON OFF )
-endif()
-if( NOT PYTHONLIBS_FOUND OR NOT PYTHONQT_FOUND )
-    message(STATUS "Disabling PythonQt modules")
-    set( WITH_PYTHONQT OFF )
+    set(WITH_PYTHON OFF)
 endif()
 
 # Now we know the state of the ABI-options, copy them into "Calamares_"
 # prefixed variables, to match how the variables would-be-named
 # when building out-of-tree.
 set(Calamares_WITH_PYTHON ${WITH_PYTHON})
-set(Calamares_WITH_PYTHONQT ${WITH_PYTHONQT})
 set(Calamares_WITH_QML ${WITH_QML})
+set(Calamares_WITH_QT6 ${WITH_QT6})
 
 ### Transifex Translation status
 #
-# Construct language lists for use.
+# Construct language lists for use. This massages the language lists if
+# needed and checks for some obvious errors. The actual work of
+# compiling translations is done in the lang/ directory.
 #
-if( Qt5_VERSION VERSION_GREATER 5.12.1 )
-    # At least Qt 5.12.2 seems to support Esperanto in QLocale
-    if( "eo" IN_LIST _tx_incomplete )
-        message(STATUS "Esperanto support since Qt 5.12.2, enabling Esperanto locale")
-        list( REMOVE_ITEM _tx_incomplete "eo" )
-        list( APPEND _tx_ok "eo" )
-    endif()
-endif()
 
-set( curr_tx ${_tx_complete} ${_tx_good} ${_tx_ok} ${_tx_incomplete} )
-set( tx_errors OFF )
-if ( curr_tx )
+set(curr_tx ${_tx_complete} ${_tx_good} ${_tx_ok} ${_tx_incomplete})
+set(tx_errors OFF)
+if(curr_tx)
     # New in list
-    foreach( l ${curr_tx} )
-        set( p_l "lang/calamares_${l}.ts" )
-        if( NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${p_l} )
+    foreach(l ${curr_tx})
+        set(p_l "lang/calamares_${l}.ts")
+        if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${p_l})
             message(WARNING "Language ${l} has no .ts file yet.")
-            set( tx_errors ON )
+            set(tx_errors ON)
         endif()
     endforeach()
 
-    unset( p_l )
-    unset( l )
+    unset(p_l)
+    unset(l)
 endif()
-unset( curr_tx )
-if( tx_errors )
-    message( FATAL_ERROR "Translation warnings, see above." )
+unset(curr_tx)
+if(tx_errors)
+    message(FATAL_ERROR "Translation warnings, see above.")
 endif()
 
-set( CALAMARES_TRANSLATION_LANGUAGES en ${_tx_complete} ${_tx_good} ${_tx_ok} )
-list( SORT CALAMARES_TRANSLATION_LANGUAGES )
+set(CALAMARES_TRANSLATION_LANGUAGES en ${_tx_complete} ${_tx_good} ${_tx_ok})
+list(SORT CALAMARES_TRANSLATION_LANGUAGES)
 
-add_subdirectory( lang )  # i18n tools
+add_subdirectory(lang) # i18n tools
 
 ### Example Distro
 #
@@ -460,22 +518,22 @@ add_subdirectory( lang )  # i18n tools
 #
 #   make example-distro
 #
-find_program( mksquashfs_PROGRAM mksquashfs )
-if( mksquashfs_PROGRAM )
-    set( mksquashfs_FOUND ON )
-    set( src_fs ${CMAKE_SOURCE_DIR}/data/example-root/ )
-    set( dst_fs ${CMAKE_BINARY_DIR}/example.sqfs )
-    if( EXISTS ${src_fs} )
+find_program(mksquashfs_PROGRAM mksquashfs)
+if(mksquashfs_PROGRAM)
+    set(mksquashfs_FOUND ON)
+    set(src_fs ${CMAKE_SOURCE_DIR}/data/example-root/)
+    set(dst_fs ${CMAKE_BINARY_DIR}/example.sqfs)
+    if(EXISTS ${src_fs})
         # based on the build host. If /lib64 exists, assume it is needed.
         # Collect directories needed for a minimal binary distro,
         # Note that the last path component is added to the root, so
         # if you add /usr/sbin here, it will be put into /sbin_1.
         # Add such paths to /etc/profile under ${src_fs}.
-        set( candidate_fs /sbin /bin /lib /lib64 )
-        set( host_fs "" )
-        foreach( c_fs ${candidate_fs} )
-            if( EXISTS ${c_fs} )
-                list( APPEND host_fs ${c_fs} )
+        set(candidate_fs /sbin /bin /lib /lib64)
+        set(host_fs "")
+        foreach(c_fs ${candidate_fs})
+            if(EXISTS ${c_fs})
+                list(APPEND host_fs ${c_fs})
             endif()
         endforeach()
         add_custom_command(
@@ -486,116 +544,88 @@ if( mksquashfs_PROGRAM )
         add_custom_target(example-distro DEPENDS ${dst_fs})
     endif()
 else()
-    set( mksquashfs_FOUND OFF )
+    set(mksquashfs_FOUND OFF)
 endif()
 # Doesn't list mksquashfs as an optional dep, though, because it
 # hasn't been sent through the find_package() scheme.
 #
 # "http://tldp.org/HOWTO/SquashFS-HOWTO/creatingandusing.html"
-add_feature_info( ExampleDistro ${mksquashfs_FOUND} "Create example-distro target.")
-
+add_feature_info(ExampleDistro ${mksquashfs_FOUND} "Create example-distro target.")
 
 ### CALAMARES PROPER
 #
-set( CALAMARES_VERSION ${CALAMARES_VERSION_MAJOR}.${CALAMARES_VERSION_MINOR}.${CALAMARES_VERSION_PATCH} )
-# In rare cases we have hotfix-releases with a tweak
-if( CALAMARES_VERSION_TWEAK )
-    set( CALAMARES_VERSION "${CALAMARES_VERSION}.${CALAMARES_VERSION_TWEAK}" )
-endif()
-set( CALAMARES_VERSION_SHORT "${CALAMARES_VERSION}" )
-if( CALAMARES_VERSION_RC )
-    set( CALAMARES_VERSION ${CALAMARES_VERSION}rc${CALAMARES_VERSION_RC} )
-endif()
 
 # Additional info for non-release builds. The "extended" version information
 # with date and git information (commit, dirty status) is used only
 # by CalamaresVersionX.h, which is included by consumers that need a full
 # version number with all that information; normal consumers can include
 # CalamaresVersion.h with more stable numbers.
-if( NOT BUILD_RELEASE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git/" )
-    include( CMakeDateStamp )
-    set( CALAMARES_VERSION_DATE "${CMAKE_DATESTAMP_YEAR}${CMAKE_DATESTAMP_MONTH}${CMAKE_DATESTAMP_DAY}" )
-    if( CALAMARES_VERSION_DATE GREATER 0 )
-        set( CALAMARES_VERSION ${CALAMARES_VERSION}.${CALAMARES_VERSION_DATE} )
-    endif()
-
-    include( CMakeVersionSource )
-    if( CMAKE_VERSION_SOURCE )
-        set( CALAMARES_VERSION ${CALAMARES_VERSION}-${CMAKE_VERSION_SOURCE} )
-    endif()
+if(NOT CALAMARES_RELEASE_MODE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git/")
+    include(ExtendedVersion)
+    extend_version( "${CALAMARES_VERSION}" OFF CALAMARES_VERSION_SHORT CALAMARES_VERSION_LONG )
 endif()
 
-# Special target for not-RC (e.g. might-be-release) builds.
-# This is used by the release script to get the version.
-if ( CALAMARES_VERSION_RC EQUAL 0 )
-    add_custom_target(show-version
-        ${CMAKE_COMMAND} -E echo CALAMARES_VERSION=${CALAMARES_VERSION_SHORT}
-        USES_TERMINAL
-    )
+# Special define for RC (e.g. not-a-release) builds.
+# This is consumed via the CalamaresConfig.h header.
+if(NOT CALAMARES_RELEASE_MODE)
+    set(CALAMARES_VERSION_RC 1)
 endif()
 
 # enforce using constBegin, constEnd for const-iterators
-add_definitions(
-    -DQT_STRICT_ITERATORS
-    -DQT_SHARED
-    -DQT_SHAREDPOINTER_TRACK_POINTERS
-)
+add_definitions(-DQT_STRICT_ITERATORS -DQT_SHARED -DQT_SHAREDPOINTER_TRACK_POINTERS)
 
 # set paths
-set( CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" )
-set( CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" )
-set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" )
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
 
 # Better default installation paths: GNUInstallDirs defines
 # CMAKE_INSTALL_FULL_SYSCONFDIR to be CMAKE_INSTALL_PREFIX/etc by default
 # but we really want /etc
-if( NOT DEFINED CMAKE_INSTALL_SYSCONFDIR )
-    set( CMAKE_INSTALL_SYSCONFDIR "/etc" )
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+    set(CMAKE_INSTALL_SYSCONFDIR "/etc")
 endif()
 
 # make predefined install dirs available everywhere
-include( GNUInstallDirs )
+include(GNUInstallDirs)
 
 # This is used by CalamaresAddLibrary; once Calamares is installed,
 # the CalamaresConfig.cmake module sets this variable to the IMPORTED
 # libraries for Calamares.
-set( Calamares_LIBRARIES calamares )
+set(Calamares_LIBRARIES calamares)
 
-add_subdirectory( src )
+add_subdirectory(3rdparty/kdsingleapplication)
+add_subdirectory(src)
 
 add_feature_info(Python ${WITH_PYTHON} "Python job modules")
-add_feature_info(PythonQt ${WITH_PYTHONQT} "Python view modules")
-add_feature_info(Config ${INSTALL_CONFIG} "Install Calamares configuration")
-add_feature_info(KCrash ${WITH_KF5Crash} "Crash dumps via KCrash")
-add_feature_info(KDBusAddons ${WITH_KF5DBus} "Unique-application via DBus")
+add_feature_info(Qml ${WITH_QML} "QML UI support")
+add_feature_info(Polkit ${INSTALL_POLKIT} "Install Polkit files")
+add_feature_info(KCrash ${BUILD_CRASH_REPORTING} "Crash dumps via KCrash")
+
+### Post-source configuration
+#
+#
+find_package(${kfname} ${KF_VERSION} QUIET COMPONENTS CoreAddons)
 
 ### CMake infrastructure installation
 #
 #
-set( CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/Calamares" CACHE PATH  "Installation directory for CMake files" )
-set( CMAKE_INSTALL_FULL_CMAKEDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR}" )
+set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/Calamares" CACHE PATH "Installation directory for CMake files")
+set(CMAKE_INSTALL_FULL_CMAKEDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR}")
 
-export( PACKAGE Calamares )
+export(PACKAGE Calamares)
 configure_package_config_file(
     "CalamaresConfig.cmake.in"
     "${PROJECT_BINARY_DIR}/CalamaresConfig.cmake"
     INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
-    PATH_VARS
-        CMAKE_INSTALL_INCLUDEDIR
-        CMAKE_INSTALL_LIBDIR
-        CMAKE_INSTALL_DATADIR
+    PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_DATADIR
 )
 write_basic_package_version_file(
     ${PROJECT_BINARY_DIR}/CalamaresConfigVersion.cmake
     VERSION ${PROJECT_VERSION}
     COMPATIBILITY SameMajorVersion
 )
-install(
-    EXPORT Calamares
-    DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
-    FILE "CalamaresTargets.cmake"
-    NAMESPACE Calamares::
-)
+install(EXPORT Calamares DESTINATION "${CMAKE_INSTALL_CMAKEDIR}" FILE "CalamaresTargets.cmake" NAMESPACE Calamares::)
 
 # Install the cmake files
 install(
@@ -609,71 +639,60 @@ install(
         "CMakeModules/CalamaresAddTest.cmake"
         "CMakeModules/CalamaresAddTranslations.cmake"
         "CMakeModules/CalamaresAutomoc.cmake"
+        "CMakeModules/CalamaresCheckModuleSelection.cmake"
         "CMakeModules/CMakeColors.cmake"
         "CMakeModules/FindYAMLCPP.cmake"
-    DESTINATION
-        "${CMAKE_INSTALL_CMAKEDIR}"
+    DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
 )
 
 ### Miscellaneous installs
 #
 #
-if( INSTALL_CONFIG )
-    install(
-        FILES settings.conf
-        DESTINATION share/calamares
-    )
+if(INSTALL_POLKIT)
+    install(FILES com.github.calamares.calamares.policy DESTINATION "${POLKITQT-1_POLICY_FILES_INSTALL_DIR}")
 endif()
 
-if( INSTALL_POLKIT )
-    install(
-        FILES com.github.calamares.calamares.policy
-        DESTINATION "${POLKITQT-1_POLICY_FILES_INSTALL_DIR}"
-    )
-endif()
-
-if ( INSTALL_COMPLETION )
-    if( NOT CMAKE_INSTALL_BASHCOMPLETIONDIR )
-        set( CMAKE_INSTALL_BASHCOMPLETIONDIR "${CMAKE_INSTALL_DATADIR}/bash-completion/completions" )
+if(INSTALL_COMPLETION)
+    if(NOT CMAKE_INSTALL_BASHCOMPLETIONDIR)
+        set(CMAKE_INSTALL_BASHCOMPLETIONDIR "${CMAKE_INSTALL_DATADIR}/bash-completion/completions")
     endif()
 
-    install( FILES ${CMAKE_SOURCE_DIR}/data/completion/bash/calamares DESTINATION "${CMAKE_INSTALL_BASHCOMPLETIONDIR}" )
+    install(FILES ${CMAKE_SOURCE_DIR}/data/completion/bash/calamares DESTINATION "${CMAKE_INSTALL_BASHCOMPLETIONDIR}")
 endif()
 
-install(
-  FILES calamares.desktop
-  DESTINATION ${CMAKE_INSTALL_DATADIR}/applications
-)
+install(FILES calamares.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
 
-install(
-    FILES man/calamares.8
-    DESTINATION ${CMAKE_INSTALL_MANDIR}/man8/
-)
+install(FILES man/calamares.8 DESTINATION ${CMAKE_INSTALL_MANDIR}/man8/)
 
-# uninstall target
+### Uninstall
+#
+#
 configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-    IMMEDIATE @ONLY
+    IMMEDIATE
+    @ONLY
 )
 
-add_custom_target( uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
-)
+add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+
+### Developer convenience
+#
+# The module support files -- .desc files, .conf files -- are copied into the build
+# directory so that it is possible to run `calamares -d` from there. Copy the
+# top-level settings.conf as well, into the build directory.
+if( settings.conf IS_NEWER_THAN ${CMAKE_BINARY_DIR}/settings.conf )
+    configure_file(settings.conf ${CMAKE_BINARY_DIR}/settings.conf COPYONLY)
+endif()
+
+
 
 ### CMAKE SUMMARY REPORT
 #
-get_directory_property( SKIPPED_MODULES
-    DIRECTORY src/modules
-    DEFINITION LIST_SKIPPED_MODULES
-)
+get_directory_property(SKIPPED_MODULES DIRECTORY src/modules DEFINITION LIST_SKIPPED_MODULES)
 calamares_explain_skipped_modules( ${SKIPPED_MODULES} )
 
-feature_summary(
-    WHAT DISABLED_FEATURES
-    DESCRIPTION "The following features have been disabled:"
-    QUIET_ON_EMPTY
-)
+feature_summary(WHAT DISABLED_FEATURES DESCRIPTION "The following features have been disabled:" QUIET_ON_EMPTY)
 feature_summary(
     WHAT OPTIONAL_PACKAGES_NOT_FOUND
     DESCRIPTION "The following OPTIONAL packages were not found:"
@@ -685,3 +704,16 @@ feature_summary(
     DESCRIPTION "The following REQUIRED packages were not found:"
     QUIET_ON_EMPTY
 )
+
+### PACKAGING
+#
+# Note: most distro's will do distro-specific packaging rather than
+#       using CPack, and this duplicates information in the AppStream, too.
+set(CPACK_PACKAGE_VENDOR calamares)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A Linux system installer")
+set(CPACK_PACKAGE_DESCRIPTION
+    "Calamares is a Linux system installer, intended for Linux distributions to use on their ISOs and other bootable media to install the distribution to the end-user's computer. Calamares can also be used as an OEM configuration tool. It is modular, extensible and highly-configurable for Linux distributions from all five major Linux families."
+)
+set(CPACK_PACKAGE_ICON "data/images/squid.png")
+
+include(CPack)

CMakeModules/BoostPython3.cmake

@@ -1,97 +0,0 @@
-# === This file is part of Calamares - <https://calamares.io> ===
-#
-#   SPDX-FileCopyrightText: 2014 Aurélien Gâteau <agateau@kde.org>
-#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
-#   SPDX-FileCopyrightText: 2019 Kevin Kofler <kevin.kofler@chello.at>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-###
-#
-# Handles the mess that Boost::Python is before CMake 3.16 and
-# Boost 1.70 or so.
-#
-###
-#
-# On Ubuntu 14.04, the libboost-python1.54-dev package comes with one library
-# for each Python version:
-# libboost_python-py27.so
-# libboost_python-py33.so
-# libboost_python-py34.so
-#
-# Boost upstream however installs Boost.Python3 libboost_python3.so, which is
-# what FindBoost.cmake is looking for. It looks for a library named
-# "libboost_${component}.so".
-#
-# On Gentoo instead, the >=dev-libs/boost-1.54 package provides boost library
-# with a name like:
-# libboost_python-2.7.so
-# libboost_python-3.3.so
-# libboost_python-3.4.so
-# depending on what python's targets you selected during install
-#
-# On Fedora >= 30 instead, the boost-python3-devel provides boost library with a
-# name like:
-# libboost_python37.so
-# depending on what python's targets you selected during install
-#
-# find_boost_python3() tries to find the package with different component
-# names. By default it tries "python3", "python-py$suffix" and
-# "python-$dotsuffix", where suffix is based on the `python_version` argument.
-# One can supply a custom component name by setting the
-# `CALAMARES_BOOST_PYTHON3_COMPONENT` variable at CMake time.
-set( CALAMARES_BOOST_PYTHON3_COMPONENT python3 CACHE STRING
-    "Name of the Boost.Python component. If Boost.Python is installed as
-    libboost_python-foo.so then this variable should be set to 'python-foo'."
-)
-
-include(FindPackageHandleStandardArgs)
-
-macro( _find_boost_python3_int boost_version componentname found_var )
-    foreach( _fbp_name ${CALAMARES_BOOST_PYTHON3_COMPONENT} ${componentname} )
-        find_package( Boost ${boost_version} QUIET COMPONENTS ${_fbp_name} )
-        string( TOUPPER ${_fbp_name} _fbp_uc_name )
-        if( Boost_${_fbp_uc_name}_FOUND )
-            if( CMAKE_SYSTEM_NAME MATCHES "FreeBSD" )
-                # No upcasing
-                set( ${found_var} ${_fbp_name} )
-            else()
-                set( ${found_var} ${_fbp_uc_name} )
-            endif()
-            break()
-        endif()
-    endforeach()
-endmacro()
-
-macro( find_boost_python3 boost_version python_version found_var )
-    set( ${found_var} OFF )
-    set( _fbp_found OFF )
-
-    # turns "3.4.123abc" into "34"
-    string( REGEX REPLACE "([0-9]+)\\.([0-9]+)\\..*" "\\1\\2" _fbp_python_short_version ${python_version} )
-    _find_boost_python3_int( ${boost_version} python-py${_fbp_python_short_version} _fbp_found )
-
-    if (NOT _fbp_found)
-        _find_boost_python3_int( ${boost_version} python${_fbp_python_short_version} _fbp_found )
-    endif()
-
-    if (NOT _fbp_found)
-        # The following loop changes the searched name for Gentoo based distributions
-        # turns "3.4.123abc" into "3.4"
-        string( REGEX REPLACE "([0-9]+)\\.([0-9]+)\\..*" "\\1.\\2" _fbp_python_short_version ${python_version} )
-        _find_boost_python3_int( ${boost_version} python-${_fbp_python_short_version} _fbp_found )
-    endif()
-
-    set( ${found_var} ${_fbp_found} )
-
-    # This is superfluous, but allows proper reporting in the features list
-    if ( _fbp_found )
-        find_package( Boost ${boost_version} COMPONENTS ${_fbp_found} )
-    else()
-        find_package( Boost ${boost_version} COMPONENTS Python )
-    endif()
-    set_package_properties(
-        Boost PROPERTIES
-        DESCRIPTION "A C++ library which enables seamless interoperability between C++ and Python 3."
-        URL "http://www.boost.org"
-    )
-endmacro()

CMakeModules/CMakeDateStamp.cmake

@@ -1,31 +0,0 @@
-# === This file is part of Calamares - <https://calamares.io> ===
-#
-#   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-###
-#
-# Find today's date, for versioning purposes.
-find_program(DATE_EXECUTABLE NAMES date)
-mark_as_advanced(DATE_EXECUTABLE)
-
-if(DATE_EXECUTABLE)
-  execute_process(
-    COMMAND ${DATE_EXECUTABLE} +%Y
-    OUTPUT_VARIABLE CMAKE_DATESTAMP_YEAR
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-  execute_process(
-    COMMAND ${DATE_EXECUTABLE} +%m
-    OUTPUT_VARIABLE CMAKE_DATESTAMP_MONTH
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-  execute_process(
-    COMMAND ${DATE_EXECUTABLE} +%d
-    OUTPUT_VARIABLE CMAKE_DATESTAMP_DAY
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  )
-endif()

CMakeModules/CMakeVersionSource.cmake

@@ -1,52 +0,0 @@
-# === This file is part of Calamares - <https://calamares.io> ===
-#
-#   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-###
-#
-# Try to identify the current development source version.
-set(CMAKE_VERSION_SOURCE "")
-if(EXISTS ${CMAKE_SOURCE_DIR}/.git/HEAD)
-  find_program(GIT_EXECUTABLE NAMES git git.cmd)
-  mark_as_advanced(GIT_EXECUTABLE)
-  if(GIT_EXECUTABLE)
-    execute_process(
-      COMMAND ${GIT_EXECUTABLE} rev-parse --verify -q --short=7 HEAD
-      OUTPUT_VARIABLE head
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-      )
-    if(head)
-      set(branch "")
-      execute_process(
-        COMMAND ${GIT_EXECUTABLE} name-rev HEAD
-        OUTPUT_VARIABLE branch
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-      string(REGEX REPLACE "HEAD " "" branch "${branch}")
-      set(CMAKE_VERSION_SOURCE "git-${branch}-${head}")
-      execute_process(
-        COMMAND ${GIT_EXECUTABLE} update-index -q --refresh
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-      execute_process(
-        COMMAND ${GIT_EXECUTABLE} diff-index --name-only HEAD --
-        OUTPUT_VARIABLE dirty
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-      if(dirty)
-        set(CMAKE_VERSION_SOURCE "${CMAKE_VERSION_SOURCE}-dirty")
-      endif()
-    endif()
-  endif()
-elseif(EXISTS ${CMAKE_SOURCE_DIR}/CVS/Repository)
-  file(READ ${CMAKE_SOURCE_DIR}/CVS/Repository repo)
-  set(branch "")
-  if("${repo}" MATCHES "\\.git/")
-    string(REGEX REPLACE ".*\\.git/([^\r\n]*).*" "-\\1" branch "${repo}")
-  endif()
-  set(CMAKE_VERSION_SOURCE "cvs${branch}")
-endif()

CMakeModules/CalamaresAddBrandingSubdirectory.cmake

@@ -101,7 +101,7 @@ function( calamares_add_branding_translations NAME )
 
     file( GLOB BRANDING_TRANSLATION_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${SUBDIRECTORY}/lang/calamares-${NAME}_*.ts" )
     if ( BRANDING_TRANSLATION_FILES )
-        qt5_add_translation( QM_FILES ${BRANDING_TRANSLATION_FILES} )
+        qt_add_translation( QM_FILES ${BRANDING_TRANSLATION_FILES} )
         add_custom_target( branding-translation-${NAME} ALL DEPENDS ${QM_FILES}
             COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/lang/
             COMMAND ${CMAKE_COMMAND} -E copy ${QM_FILES} ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/lang/

CMakeModules/CalamaresAddLibrary.cmake

@@ -62,8 +62,10 @@ function(calamares_add_library)
         add_library(${target} STATIC ${LIBRARY_SOURCES})
     elseif(LIBRARY_TARGET_TYPE STREQUAL "MODULE")
         add_library(${target} MODULE ${LIBRARY_SOURCES})
-    else() # default
+    elseif(LIBRARY_TARGET_TYPE STREQUAL "SHARED")
         add_library(${target} SHARED ${LIBRARY_SOURCES})
+    else() # default
+        message(FATAL_ERROR "Invalid library type '${LIBRARY_TARGET_TYPE}'")
     endif()
 
     calamares_automoc(${target})
@@ -86,9 +88,9 @@ function(calamares_add_library)
     # add link targets
     target_link_libraries(${target}
         LINK_PUBLIC ${Calamares_LIBRARIES}
-        Qt5::Core
-        Qt5::Gui
-        Qt5::Widgets
+        ${qtname}::Core
+        ${qtname}::Gui
+        ${qtname}::Widgets
     )
     if(LIBRARY_LINK_LIBRARIES)
         target_link_libraries(${target} LINK_PUBLIC ${LIBRARY_LINK_LIBRARIES})

CMakeModules/CalamaresAddModuleSubdirectory.cmake

@@ -12,33 +12,83 @@
 # Function and support code for adding a Calamares module (either a Qt / C++ plugin,
 # or a Python module, or whatever) to the build.
 #
+# # Usage
+#
+# The public API is one single function:
+#
+# - calamares_add_module_subdirectory(subdirectory [skiplistvar])
+#   Adds a given *subdirectory* to the modules list, building the
+#   module that is there. The *subdirectory* must contain a `module.desc`
+#   (generally non-C++ modules) or a `CMakeLists.txt` (for C++ modules,
+#   or special cases). The module is assumed to be named after the
+#   (last component of) the subdirectory.
+#
+#   If the module would be skipped (by the global SKIP_MODULES setting
+#   or a USE_* setting) or the module itself sets a reason to skip
+#   via the calamares_skip_module() function, the module is added to
+#   the list of skipped-modules in *skiplistvar*. If no variable is
+#   given, the reason is set in the parent scope variable
+#   SKIPPED_MODULES . Do **not** use SKIPPED_MODULES as the name of
+#   *skiplistvar*, things will get weird.
+#
+#   Do note that the name of a module must be the same as the name of
+#   the directory containing it (as documented in src/modules/README.md).
+#   This applies to both C++ and Python modules, and allows the use of
+#   the subdirectory as a proxy for the module name inside.
+#
+
 include( CalamaresAddTranslations )
+include( CalamaresCheckModuleSelection )
 
 set( MODULE_DATA_DESTINATION share/calamares/modules )
 
-# Convenience function to indicate that a module has been skipped
-# (optionally also why). Call this in the module's CMakeLists.txt
-macro( calamares_skip_module )
-    set( SKIPPED_MODULES ${SKIPPED_MODULES} ${ARGV} PARENT_SCOPE )
-endmacro()
+# We look for Pylint (just once) so that unittests can be added that
+# check the syntax / variables of Python modules. This should help
+# avoid more typo's-in-releases.
+if(BUILD_TESTING AND NOT PYLINT_COMMAND_SEARCHED)
+    set(PYLINT_COMMAND_SEARCHED TRUE)
+    find_program(
+        PYLINT_COMMAND
+        NAMES pylint3 pylint
+        PATHS $ENV{HOME}/.local/bin
+        )
+endif()
 
-function( calamares_explain_skipped_modules )
-    if ( ARGN )
-        message( "${ColorReset}-- Skipped modules:" )
-        foreach( SUBDIRECTORY ${ARGN} )
-            message( "${ColorReset}--   Skipped ${BoldRed}${SUBDIRECTORY}${ColorReset}." )
-        endforeach()
-        message( "" )
-    endif()
-endfunction()
-
-function( calamares_add_module_subdirectory )
+function( _calamares_add_module_subdirectory_impl )
     set( SUBDIRECTORY ${ARGV0} )
 
-    set( SKIPPED_MODULES )
+    # Set SKIPPED_MODULES here, so CMake-based modules have a
+    # parent scope to set it in; this function, in turn sets it
+    # in **its** parent scope.
+    set( SKIPPED_MODULES "" )
     set( MODULE_CONFIG_FILES "" )
 
+    # The module subdirectory may be given as a/b/c, but the module
+    # needs to be installed as "c", so we split off any intermediate
+    # directories.
+    #
+    # Compute _modulename (the last directory name) and _mod_dir
+    # (the full path to the module sources).
+    get_filename_component(_dirname "${SUBDIRECTORY}" DIRECTORY)
+    if( _dirname )
+        # Remove the dirname and any leftover leading /s
+        string( REGEX REPLACE "^${_dirname}/*" "" _modulename "${SUBDIRECTORY}" )
+    else()
+        set( _modulename ${SUBDIRECTORY} )
+    endif()
+    # Strip any remaining /
+    string( REGEX REPLACE "/" "" _modulename "${_modulename}" )
     set( _mod_dir "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}" )
+
+    # Skip list check applies to all kinds of modules
+    calamares_check_skip( ${_modulename} SKIPPED_MODULES )
+    if ( SKIPPED_MODULES )
+        # If it's skipped by infrastucture, the message already includes the module
+        # name. We don't need to do any further checking.
+        set( SKIPPED_MODULES "${SKIPPED_MODULES}" PARENT_SCOPE )
+        return()
+    endif()
+
     # If this subdirectory has a CMakeLists.txt, we add_subdirectory it...
     if( EXISTS "${_mod_dir}/CMakeLists.txt" )
         add_subdirectory( ${SUBDIRECTORY} )
@@ -48,21 +98,21 @@ function( calamares_add_module_subdirectory )
         if ( SKIPPED_MODULES )
             set( SKIPPED_MODULES ${SKIPPED_MODULES} PARENT_SCOPE )
             set( MODULE_CONFIG_FILES "" )
+        else()
+            # The SKIPPED_MODULES may be set in the directory itself
+            get_directory_property( _skip DIRECTORY ${SUBDIRECTORY} DEFINITION SKIPPED_MODULES )
+            if ( _skip )
+                set( SKIPPED_MODULES ${_skip} PARENT_SCOPE )
+                set( MODULE_CONFIG_FILES "" )
+            endif()
+        endif()
+        if ( SKIPPED_MODULES )
+            return()
         endif()
     # ...otherwise, we look for a module.desc.
     elseif( EXISTS "${_mod_dir}/module.desc" )
         set( MODULES_DIR ${CMAKE_INSTALL_LIBDIR}/calamares/modules )
-        # The module subdirectory may be given as a/b/c, but the module
-        # needs to be installed as "c", so we split off any intermediate
-        # directories.
-        get_filename_component(_dirname "${SUBDIRECTORY}" DIRECTORY)
-        if( _dirname )
-            # Remove the dirname and any leftover leading /s
-            string( REGEX REPLACE "^${_dirname}/*" "" _modulename "${SUBDIRECTORY}" )
-            set( MODULE_DESTINATION ${MODULES_DIR}/${_modulename} )
-        else()
-            set( MODULE_DESTINATION ${MODULES_DIR}/${SUBDIRECTORY} )
-        endif()
+        set( MODULE_DESTINATION ${MODULES_DIR}/${_modulename} )
 
         # Read module.desc, check that the interface type is supported.
         #
@@ -71,7 +121,8 @@ function( calamares_add_module_subdirectory )
         # _mod_testing boolean if the module should be added to the loadmodule tests
         file(STRINGS "${_mod_dir}/module.desc" MODULE_INTERFACE REGEX "^interface")
         if ( MODULE_INTERFACE MATCHES "pythonqt" )
-            set( _mod_enabled ${Calamares_WITH_PYTHONQT} )
+            message( FATAL_ERROR "PythonQt is no longer supported" )
+            set( _mod_enabled OFF )
             set( _mod_reason "No PythonQt support" )
             set( _mod_testing OFF )
         elseif ( MODULE_INTERFACE MATCHES "python" )
@@ -102,28 +153,21 @@ function( calamares_add_module_subdirectory )
 
                     get_filename_component( FLEXT ${MODULE_FILE} EXT )
                     if( "${FLEXT}" STREQUAL ".conf" )
-                        if( INSTALL_CONFIG )
-                            install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/${MODULE_FILE}
-                                    DESTINATION ${MODULE_DATA_DESTINATION} )
-                        endif()
+                        message(STATUS "Config ${MODULE_FILE}")
                         list( APPEND MODULE_CONFIG_FILES ${MODULE_FILE} )
                     else()
+                        message(STATUS "Non-Config ${MODULE_FILE}")
                         install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${SUBDIRECTORY}/${MODULE_FILE}
                                  DESTINATION ${MODULE_DESTINATION} )
                     endif()
                 endif()
             endforeach()
 
-            message( "-- ${BoldYellow}Found ${CALAMARES_APPLICATION_NAME} module: ${BoldRed}${SUBDIRECTORY}${ColorReset}" )
+            message( "-- ${BoldYellow}Found ${CALAMARES_APPLICATION_NAME} module: ${BoldRed}${_modulename}${ColorReset}" )
             message( "   ${Green}TYPE:${ColorReset} jobmodule" )
             message( "   ${Green}MODULE_DESTINATION:${ColorReset} ${MODULE_DESTINATION}" )
             if( MODULE_CONFIG_FILES )
-                if ( INSTALL_CONFIG )
-                    set( _destination "${MODULE_DATA_DESTINATION}" )
-                else()
-                    set( _destination "[Build directory only]" )
-                endif()
-                message( "   ${Green}CONFIGURATION_FILES:${ColorReset} ${MODULE_CONFIG_FILES} => ${_destination}" )
+                message( "   ${Green}CONFIGURATION_FILES:${ColorReset} ${MODULE_CONFIG_FILES} => [Build directory only]" )
             endif()
             message( "" )
             # We copy over the lang directory, if any
@@ -159,7 +203,9 @@ function( calamares_add_module_subdirectory )
         endforeach()
     endif()
 
-    # Check that the module can be loaded. Since this calls exec(), the module
+    # Adding general tests
+    #
+    # Add a check that the module can be loaded. Since this calls exec(), the module
     # may try to do things to the running system. Needs work to make that a
     # safe thing to do.
     #
@@ -201,5 +247,34 @@ function( calamares_add_module_subdirectory )
         if ( EXISTS ${_testdir}/CMakeTests.txt AND NOT EXISTS ${_mod_dir}/CMakeLists.txt )
             include( ${_testdir}/CMakeTests.txt )
         endif()
+        if ( PYLINT_COMMAND AND MODULE_INTERFACE MATCHES "python" )
+            # Python modules get an additional test via pylint; this
+            # needs to run at top-level because the ci/libcalamares directory
+            # contains API stubs.
+            #
+            # TODO: the entry point is assumed to be `main.py`, but that is
+            #       configurable through module.desc
+            add_test(
+                NAME lint-${SUBDIRECTORY}
+                COMMAND env PYTHONPATH=ci: ${PYLINT_COMMAND} -E ${_mod_dir}/main.py
+                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                )
+        endif()
+    endif()
+endfunction()
+
+function( calamares_add_module_subdirectory )
+    set( SUBDIRECTORY ${ARGV0} )
+    set( _ams_SKIP_LIST ${ARGV1} )
+
+    set( SKIPPED_MODULES "" )
+    _calamares_add_module_subdirectory_impl( ${SUBDIRECTORY} )
+    if ( SKIPPED_MODULES )
+        if ( _ams_SKIP_LIST )
+            list( APPEND ${_ams_SKIP_LIST} "${SKIPPED_MODULES}" )
+            set( ${_ams_SKIP_LIST} "${${_ams_SKIP_LIST}}" PARENT_SCOPE )
+        else()
+            set( SKIPPED_MODULES "${SKIPPED_MODULES}" PARENT_SCOPE )
+        endif()
     endif()
 endfunction()

CMakeModules/CalamaresAddPlugin.cmake

@@ -59,9 +59,17 @@
 #       If this is set, writes an explicit weight into the module.desc;
 #       module weights are used in progress reporting.
 #
+#
+# This function follows the global SKIP_MODULES and USE_* settings, so
+# a plugin may be skipped -- then nothing will be built. In that case,
+# SKIPPED_MODULES is set in the parent (i.e. caller's) scope with the
+# reason why. This should rarely be a concern as AddModuleSubdirectory
+# already handles skip-reasons and collects them for reporting.
 
 include( CMakeParseArguments )
+
 include( CalamaresAddLibrary  )
+include( CalamaresCheckModuleSelection )
 include( CMakeColors )
 
 function( calamares_add_plugin )
@@ -80,6 +88,12 @@ function( calamares_add_plugin )
     set( CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" )
     set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" )
 
+    calamares_check_skip( ${NAME} _skip)
+    if ( _skip )
+        set( SKIPPED_MODULES "${_skip}" PARENT_SCOPE )
+        return()
+    endif()
+
     message( "-- ${BoldYellow}Found ${CALAMARES_APPLICATION_NAME} module: ${BoldRed}${PLUGIN_NAME}${ColorReset}" )
     message( "   ${Green}TYPE:${ColorReset} ${PLUGIN_TYPE}" )
     message( "   ${Green}LINK_LIBRARIES:${ColorReset} ${PLUGIN_LINK_LIBRARIES}" )
@@ -90,10 +104,7 @@ function( calamares_add_plugin )
             message( FATAL_ERROR "${Red}NO_CONFIG${ColorReset} is set, with configuration ${Red}${PLUGIN_CONFIG_FILES}${ColorReset}" )
         endif()
         set( _destination "(unknown)" )
-        if ( INSTALL_CONFIG AND NOT PLUGIN_NO_INSTALL )
-            set( _destination "${PLUGIN_DATA_DESTINATION}" )
-        elseif( NOT PLUGIN_NO_INSTALL )
-            # Not INSTALL_CONFIG
+        if( NOT PLUGIN_NO_INSTALL )
             set( _destination "[Build directory only]" )
         else()
             set( _destination "[Skipping installation]" )
@@ -112,6 +123,15 @@ function( calamares_add_plugin )
     # create target name once for convenience
     set( target "calamares_${PLUGIN_TYPE}_${PLUGIN_NAME}" )
 
+    # automatic library linkage
+    if(PLUGIN_TYPE STREQUAL "view" OR PLUGIN_TYPE STREQUAL "viewmodule")
+        list(APPEND PLUGIN_LINK_PRIVATE_LIBRARIES Calamares::calamaresui)
+    elseif(PLUGIN_TYPE STREQUAL "job")
+        list(APPEND PLUGIN_LINK_PRIVATE_LIBRARIES Calamares::calamares)
+    else()
+        message(FATAL_ERROR "Unknown plugin type ${PLUGIN_TYPE}")
+    endif()
+
     # determine target type
     if( NOT ${PLUGIN_SHARED_LIB} )
         set( target_type "MODULE" )
@@ -187,17 +207,12 @@ function( calamares_add_plugin )
 
         set( _warned_config OFF )
         foreach( PLUGIN_CONFIG_FILE ${PLUGIN_CONFIG_FILES} )
-            if( ${CMAKE_CURRENT_SOURCE_DIR}/${PLUGIN_CONFIG_FILE} IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/${PLUGIN_CONFIG_FILE} OR INSTALL_CONFIG )
+            if( ${CMAKE_CURRENT_SOURCE_DIR}/${PLUGIN_CONFIG_FILE} IS_NEWER_THAN ${CMAKE_CURRENT_BINARY_DIR}/${PLUGIN_CONFIG_FILE} )
                 configure_file( ${PLUGIN_CONFIG_FILE} ${PLUGIN_CONFIG_FILE} COPYONLY )
             else()
                 message( "   ${BoldYellow}Not updating${ColorReset} ${PLUGIN_CONFIG_FILE}" )
                 set( _warned_config ON )
             endif()
-            if ( INSTALL_CONFIG )
-                install(
-                    FILES ${CMAKE_CURRENT_BINARY_DIR}/${PLUGIN_CONFIG_FILE}
-                    DESTINATION ${PLUGIN_DATA_DESTINATION} )
-            endif()
         endforeach()
         if ( _warned_config )
             message( "" )

CMakeModules/CalamaresAddTest.cmake

@@ -18,37 +18,38 @@
 #   SOURCES <FILE..>
 #   )
 
-include( CMakeParseArguments )
-include( CalamaresAutomoc )
+include(CMakeParseArguments)
+include(CalamaresAutomoc)
 
-function( calamares_add_test )
-    # parse arguments (name needs to be saved before passing ARGN into the macro)
-    set( NAME ${ARGV0} )
-    set( options GUI )
-    set( oneValueArgs NAME RESOURCES )
-    set( multiValueArgs SOURCES LIBRARIES DEFINITIONS )
-    cmake_parse_arguments( TEST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
-    set( TEST_NAME ${NAME} )
+function(calamares_add_test name)
+    set(options GUI)
+    set(oneValueArgs RESOURCES)
+    set(multiValueArgs SOURCES LIBRARIES DEFINITIONS)
+    cmake_parse_arguments(TEST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    set(TEST_NAME ${name})
 
-    if( ECM_FOUND AND BUILD_TESTING )
+    if(ECM_FOUND AND BUILD_TESTING)
         ecm_add_test(
             ${TEST_SOURCES} ${TEST_RESOURCES}
             TEST_NAME
                 ${TEST_NAME}
             LINK_LIBRARIES
-                calamares
+                Calamares::calamares
                 ${TEST_LIBRARIES}
-                Qt5::Core
-                Qt5::Test
-            )
+                ${qtname}::Core
+                ${qtname}::Test
+        )
         calamares_automoc( ${TEST_NAME} )
         # We specifically pass in the source directory of the test-being-
         # compiled, so that it can find test-files in that source dir.
-        target_compile_definitions( ${TEST_NAME} PRIVATE -DBUILD_AS_TEST="${CMAKE_CURRENT_SOURCE_DIR}"  ${TEST_DEFINITIONS} )
-        if( TEST_GUI )
-            target_link_libraries( ${TEST_NAME} calamaresui Qt5::Gui )
+        target_compile_definitions(
+            ${TEST_NAME}
+            PRIVATE -DBUILD_AS_TEST="${CMAKE_CURRENT_SOURCE_DIR}" ${TEST_DEFINITIONS}
+        )
+        if(TEST_GUI)
+            target_link_libraries(${TEST_NAME} Calamares::calamaresui ${qtname}::Gui)
         endif()
-        if( TEST_RESOURCES )
+        if(TEST_RESOURCES)
             calamares_autorcc( ${TEST_NAME} ${TEST_RESOURCES} )
         endif()
     endif()

CMakeModules/CalamaresAddTranslations.cmake

@@ -100,3 +100,58 @@ function( install_calamares_gettext_translations )
         endif()
     endforeach()
 endfunction()
+
+set(_calamares_qrc_translations_qrc_source ${CMAKE_CURRENT_LIST_DIR}/i18n.qrc.in) # Needs to be set outside of function
+function(calamares_qrc_translations basename)
+    set(options "")
+    set(oneValueArgs SUBDIRECTORY OUTPUT_VARIABLE)
+    set(multiValueArgs PREFIXES LANGUAGES)
+    cmake_parse_arguments(_qrt "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT _qrt_OUTPUT_VARIABLE)
+        message(FATAL_ERROR "No output variable")
+    endif()
+    if(NOT _qrt_PREFIXES)
+        set(_qrt_PREFIXES "${basename}")
+    endif()
+    if(NOT _qrt_LANGUAGES)
+        set(_qrt_LANGUAGES ${CALAMARES_TRANSLATION_LANGUAGES})
+    endif()
+    if(NOT _qrt_SUBDIRECTORY)
+        set(_qrt_SUBDIRECTORY "")
+    endif()
+
+    set(translations_qrc_infile ${CMAKE_CURRENT_BINARY_DIR}/${basename}.qrc)
+    set(translations_qrc_outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${basename}.cxx)
+
+    # Must use this variable name because of the @ substitution
+    set(calamares_i18n_qrc_content "")
+    set(calamares_i18n_ts_filelist "")
+    foreach(lang ${_qrt_LANGUAGES})
+        foreach(tlsource ${_qrt_PREFIXES})
+            if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_qrt_SUBDIRECTORY}/${tlsource}_${lang}.ts")
+                string(APPEND calamares_i18n_qrc_content "<file>${tlsource}_${lang}.qm</file>\n")
+                list(APPEND calamares_i18n_ts_filelist "${CMAKE_CURRENT_SOURCE_DIR}/${_qrt_SUBDIRECTORY}/${tlsource}_${lang}.ts")
+            endif()
+        endforeach()
+    endforeach()
+
+    configure_file(${_calamares_qrc_translations_qrc_source} ${translations_qrc_infile} @ONLY)
+    qt_add_translation(QM_FILES ${calamares_i18n_ts_filelist})
+
+    # Run the resource compiler (rcc_options should already be set)
+    add_custom_command(
+        OUTPUT ${translations_qrc_outfile}
+        COMMAND ${qtname}::rcc
+        ARGS
+            ${rcc_options}
+            --format-version 1
+            -name ${basename}
+            -o ${translations_qrc_outfile}
+            ${translations_qrc_infile}
+        MAIN_DEPENDENCY ${translations_qrc_infile}
+        DEPENDS ${QM_FILES}
+    )
+
+    set(${_qrt_OUTPUT_VARIABLE} ${translations_qrc_outfile} PARENT_SCOPE)
+endfunction()

CMakeModules/CalamaresCheckModuleSelection.cmake

@@ -0,0 +1,116 @@
+# === This file is part of Calamares - <https://calamares.io> ===
+#
+#   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
+#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
+#   SPDX-License-Identifier: BSD-2-Clause
+#
+#   Calamares is Free Software: see the License-Identifier above.
+#
+###
+#
+# This module implements the "skip modules" part of configuring
+# the Calamares repository or an external-modules repository.
+#
+# It should not be necessary to include() this module explicitly,
+# since both AddPlugin and AddModuleSubdirectory do so implicitly.
+#
+#
+# # Usage
+#
+# The public API is two functions:
+#
+# - calamares_skip_module(reason)
+#   A C++ module (or any that uses CMake) can call this macro to
+#   add *reason* to the list of skipped modules. Typically a module
+#   will pass in "modulename (why)" so that it is clear **which**
+#   module is skipped. This macro should be called at the top-level
+#   of a module's CMakeLists.txt and the module should then **not**
+#   call calamares_add_plugin().
+# - calamares_explain_skipped_modules(list...)
+#   This will print out all the module reasons (see above) that have
+#   been added to the given *listvar*. When AddModuleSubdirectory is
+#   used as the mechanism to add all the subdirectories in the repository
+#   that contain modules, with a consistent *listvar* setting,
+#   this will show all the modules that have been skipped.
+#
+# The internal API is one function:
+#
+# - calamares_check_skip(modulename outvar)
+#   Checks if the *modulename* has been listed in the global SKIP_MODULES
+#   variable (to skip specifically-named modules) or if there is a USE_*
+#   setting applicable to the module. If the module is skipped for this
+#   reason, a suitable entry is added to *outvar* as if
+#   calamares_skip_module() had been called.
+#
+# Best practice is to pick a variable to collect all of the skipped
+# modules, and to pass the name of that variable to AddModuleSubdirectory
+# in each call. After all subdirectories have been added, call
+# calamares_explain_skipped_modules() with the value of that variable.
+
+
+# Convenience function to indicate that a module has been skipped
+# (optionally also why). Call this in the module's CMakeLists.txt
+macro( calamares_skip_module )
+    set( SKIPPED_MODULES ${SKIPPED_MODULES} ${ARGV} PARENT_SCOPE )
+endmacro()
+
+function( calamares_explain_skipped_modules )
+    if ( ARGN )
+        message( "${ColorReset}-- Skipped modules:" )
+        foreach( SUBDIRECTORY ${ARGN} )
+            message( "${ColorReset}--   Skipped ${BoldRed}${SUBDIRECTORY}${ColorReset}." )
+        endforeach()
+        message( "" )
+    endif()
+endfunction()
+
+# Globally, SKIP_MODULES and USE_* affect what modules are built.
+# Check if *modulename* should be skipped, and if so, set *outvar* to
+# a human-readable reason for skipping it.
+function( _calamares_check_skip_impl modulename outvar )
+    # Globally-defined SKIP_MODULES may be space- or semicolon- separated
+    # so convert it to a list-variable.
+    string( REPLACE " " ";" SKIP_LIST "${SKIP_MODULES}" )
+
+    list( FIND SKIP_LIST "${modulename}" DO_SKIP )
+    if( NOT DO_SKIP EQUAL -1 )
+        set( ${outvar} "user request" PARENT_SCOPE )
+        return()
+    endif()
+
+    # Not skipped by the global check, see if it has an applicable USE_*
+    if( "${modulename}" MATCHES "^[a-zA-Z0-9_]+-" )
+        # Split the name into <category>-<implementation>
+        string( REGEX REPLACE "-.*" "" _category "${modulename}" )
+        string( REGEX REPLACE "^[^-]+-" "" _implementation "${modulename}" )
+    else()
+        # Not a module to which USE_* applies
+        return()
+    endif()
+
+    if( "${USE_${_category}}" STREQUAL "none" )
+        set( ${outvar} "category ${_category} disabled" PARENT_SCOPE )
+        return()
+    elseif( "${USE_${_category}}" STREQUAL "" )
+        # Category not set at all or nonexistent
+        return()
+    endif()
+
+    if ( "${USE_${_category}}" STREQUAL "${_implementation}" )
+        # Matches, so accept this module
+    else()
+        set( ${outvar} "category ${_category} selects ${USE_${_category}}" PARENT_SCOPE )
+    endif()
+endfunction()
+
+# This is the public API;it calls the _impl version so that there
+# is an extra intermediate scope for the subdirectory to write results into.
+function( calamares_check_skip modulename outvar )
+    set( _skip "" )
+    _calamares_check_skip_impl( "${modulename}" _skip )
+    if ( _skip )
+        message( "${ColorReset}-- Skipping module ${BoldRed}${modulename} (${_skip})${ColorReset}." )
+        message( "" )
+        set( ${outvar} "${modulename} (${_skip})" PARENT_SCOPE )
+    endif()
+endfunction()

CMakeModules/ExtendedVersion.cmake

@@ -0,0 +1,70 @@
+# === This file is part of Calamares - <https://calamares.io> ===
+#
+#   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
+#   SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+#   SPDX-License-Identifier: BSD-2-Clause
+#
+###
+#
+# This file defines one function for extending a VERSION-like value
+# with date and git information (if desired).
+#
+# - extend_version( version-string short_only short_var long_var )
+#   Calling this function will copy *version-string* (which would typically
+#   be a semver-style string, like "3.2.40") into the variable *short_var*.
+#   If *short_only* is true, then:
+#       - the short version is also copied into the variable *long_var*,
+#   If *short_only* is false, then:
+#       - the *version-string* plus date and git information, is copied
+#         into the varialbe *long_var*, in the format {version}-{date}-{hash}
+#
+#
+
+function( get_git_version_info out_var )
+    set(CMAKE_VERSION_SOURCE "")
+    if(EXISTS ${CMAKE_SOURCE_DIR}/.git/HEAD)
+        find_program(GIT_EXECUTABLE NAMES git git.cmd)
+        mark_as_advanced(GIT_EXECUTABLE)
+        if(GIT_EXECUTABLE)
+            execute_process(
+                COMMAND ${GIT_EXECUTABLE} rev-parse --verify -q --short=8 HEAD
+                OUTPUT_VARIABLE head
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+            )
+            if(head)
+                set(CMAKE_VERSION_SOURCE "${head}")
+                execute_process(
+                    COMMAND ${GIT_EXECUTABLE} update-index -q --refresh
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                )
+                execute_process(
+                    COMMAND ${GIT_EXECUTABLE} diff-index --name-only HEAD --
+                    OUTPUT_VARIABLE dirty
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                )
+                if(dirty)
+                    set(CMAKE_VERSION_SOURCE "${CMAKE_VERSION_SOURCE}-dirty")
+                endif()
+            endif()
+        endif()
+    endif()
+    set( ${out_var} "${CMAKE_VERSION_SOURCE}" PARENT_SCOPE )
+endfunction()
+
+function( extend_version version short_only short_var long_var )
+    set( ${short_var} "${version}" PARENT_SCOPE )
+    set( _v "${version}" )
+    if ( NOT short_only )
+        string( TIMESTAMP CALAMARES_VERSION_DATE "%Y%m%d" )
+        if( CALAMARES_VERSION_DATE GREATER 0 )
+            set( _v ${_v}.${CALAMARES_VERSION_DATE} )
+        endif()
+        get_git_version_info( _gitv )
+        if( _gitv )
+            set( _v "${_v}-${_gitv}" )
+        endif()
+    endif()
+    set( ${long_var} "${_v}" PARENT_SCOPE )
+endfunction()

CMakeModules/FindPythonQt.cmake

@@ -1,185 +0,0 @@
-# === This file is part of Calamares - <https://calamares.io> ===
-#
-#   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
-#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-###
-#
-# Find PythonQt
-#
-# Sets PYTHONQT_FOUND, PYTHONQT_INCLUDE_DIR, PYTHONQT_LIBRARY, PYTHONQT_LIBRARIES
-#
-# Also sets PYTHONQT_INCLUDE_DIRS to add whatever directories
-#   that are needed for extensions.
-#
-
-# Python is required
-find_package(PythonLibs)
-if(NOT PYTHONLIBS_FOUND)
-  message(FATAL_ERROR "error: Python is required to build PythonQt")
-endif()
-
-# Cut X.Y[.Z] down to just X.Y
-string(REGEX REPLACE
-    "^([0-9][0-9]*)\.([0-9][0-9]*)"
-    "\\1.\\2@"
-    _PYTHONLIBS_MAJMIN
-    ${PYTHONLIBS_VERSION_STRING}
-)
-string(REGEX REPLACE
-    "@.*"
-    ""
-    PYTHONLIBS_MAJMIN
-    ${_PYTHONLIBS_MAJMIN}
-)
-
-if(NOT EXISTS "${PYTHONQT_INSTALL_DIR}")
-    find_path(PYTHONQT_INSTALL_DIR
-        NAMES
-            include/PythonQt/PythonQt.h
-            include/PythonQt5/PythonQt.h
-        DOC "Directory where PythonQt was installed.")
-endif()
-
-# XXX Since PythonQt 3.0 is not yet cmakeified, depending
-#     on how PythonQt is built, headers will not always be
-#     installed in "include/PythonQt". That is why "src"
-#     is added as an option. See [1] for more details.
-#     [1] https://github.com/commontk/CTK/pull/538#issuecomment-86106367
-find_path(PYTHONQT_INCLUDE_DIR PythonQt.h
-    PATHS
-        "${PYTHONQT_INSTALL_DIR}/include/PythonQt"
-        "${PYTHONQT_INSTALL_DIR}/include/PythonQt5"
-        "${PYTHONQT_INSTALL_DIR}/src"
-    DOC "Path to the PythonQt include directory")
-find_path(PYTHONQT_ALL_INCLUDE_DIR PythonQt_QtAll.h
-    PATHS
-        "${PYTHONQT_INCLUDE_DIR}"
-        "${PYTHONQT_INSTALL_DIR}"
-    PATH_SUFFIXES
-        "extensions/PythonQt_QtAll"
-        "src"
-    DOC "Path to the PythonQt 'all' header")
-
-if ( NOT PythonQt_FIND_QUIETLY )
-    message( STATUS "Searching for PythonQt (PythonLibs ${PYTHONLIBS_MAJMIN}) .." )
-    if ( PYTHONQT_INCLUDE_DIR )
-        message( STATUS "  .. found include ${PYTHONQT_INCLUDE_DIR}" )
-        message( STATUS "  .. found all include ${PYTHONQT_ALL_INCLUDE_DIR}" )
-    endif()
-endif()
-
-# Minimum v3.1 is needed
-find_library(PYTHONQT_LIBRARY_RELEASE
-    NAMES
-        PythonQt-Qt5-Python${PYTHONLIBS_MAJMIN}
-        PythonQt-Qt5-Python3
-        PythonQt
-    PATHS "${PYTHONQT_INSTALL_DIR}/lib"
-    DOC "The PythonQt library."
-)
-find_library(PYTHONQT_LIBRARY_DEBUG
-    NAMES
-        PythonQt-Qt5-Python${PYTHONLIBS_MAJMIN}JMIN${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt-Qt5-Python${PYTHONLIBS_MAJMIN}${CMAKE_DEBUG_POSTFIX}
-        PythonQt-Qt5-Python${PYTHONLIBS_MAJMIN}
-        PythonQt-Qt5-Python3${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt-Qt5-Python3${CMAKE_DEBUG_POSTFIX}
-        PythonQt-Qt5-Python3
-        PythonQt${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt${CMAKE_DEBUG_POSTFIX}
-        PythonQt
-    PATHS "${PYTHONQT_INSTALL_DIR}/lib"
-    DOC "The PythonQt library (debug build)."
-)
-find_library(PYTHONQT_QTALL_LIBRARY_RELEASE
-    NAMES
-        PythonQt_QtAll-Qt5-Python${PYTHONLIBS_MAJMIN}
-        PythonQt_QtAll-Qt5-Python3
-        PythonQt_QtAll
-    PATHS "${PYTHONQT_INSTALL_DIR}/lib"
-    DOC "Full Qt bindings for the PythonQt library."
-)
-find_library(PYTHONQT_QTALL_LIBRARY_DEBUG
-    NAMES
-        PythonQt_QtAll-Qt5-Python${PYTHONLIBS_MAJMIN}${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll-Qt5-Python${PYTHONLIBS_MAJMIN}${CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll-Qt5-Python${PYTHONLIBS_MAJMIN}
-        PythonQt_QtAll-Qt5-Python3${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll-Qt5-Python3${CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll-Qt5-Python3
-        PythonQt_QtAll${CTK_CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll${CMAKE_DEBUG_POSTFIX}
-        PythonQt_QtAll
-    PATHS "${PYTHONQT_INSTALL_DIR}/lib"
-    DOC "Full Qt bindings for the PythonQt library (debug build)."
-)
-
-set(PYTHONQT_LIBRARY)
-if(PYTHONQT_LIBRARY_RELEASE)
-  list(APPEND PYTHONQT_LIBRARY optimized ${PYTHONQT_LIBRARY_RELEASE})
-endif()
-if(PYTHONQT_LIBRARY_DEBUG)
-  list(APPEND PYTHONQT_LIBRARY debug ${PYTHONQT_LIBRARY_DEBUG})
-endif()
-
-set(PYTHONQT_QTALL_LIBRARY)
-if(PYTHONQT_QTALL_LIBRARY_RELEASE)
-  list(APPEND PYTHONQT_QTALL_LIBRARY optimized ${PYTHONQT_QTALL_LIBRARY_RELEASE})
-endif()
-if(PYTHONQT_QTALL_LIBRARY_DEBUG)
-  list(APPEND PYTHONQT_QTALL_LIBRARY debug ${PYTHONQT_QTALL_LIBRARY_DEBUG})
-endif()
-
-if ( NOT PythonQt_FIND_QUIETLY )
-    if ( PYTHONQT_LIBRARY )
-        message( STATUS "  .. found library ${PYTHONQT_LIBRARY}" )
-    endif()
-    if ( PYTHONQT_QTALL_LIBRARY )
-        message( STATUS "  .. found qtall   ${PYTHONQT_QTALL_LIBRARY}" )
-    endif()
-endif()
-
-
-mark_as_advanced(PYTHONQT_INSTALL_DIR)
-mark_as_advanced(PYTHONQT_INCLUDE_DIR)
-mark_as_advanced(PYTHONQT_LIBRARY_RELEASE)
-mark_as_advanced(PYTHONQT_LIBRARY_DEBUG)
-mark_as_advanced(PYTHONQT_QTALL_LIBRARY_RELEASE)
-mark_as_advanced(PYTHONQT_QTALL_LIBRARY_DEBUG)
-
-# On linux, also find libutil
-if(UNIX AND NOT APPLE)
-  find_library(PYTHONQT_LIBUTIL util)
-  mark_as_advanced(PYTHONQT_LIBUTIL)
-endif()
-
-# All upper case _FOUND variable is maintained for backwards compatibility.
-set(PYTHONQT_FOUND 0)
-set(PythonQt_FOUND 0)
-
-if(PYTHONQT_INCLUDE_DIR AND PYTHONQT_LIBRARY AND PYTHONQT_QTALL_LIBRARY)
-  # Currently CMake'ified PythonQt only supports building against a python Release build.
-  # This applies independently of CTK build type (Release, Debug, ...)
-  add_definitions(-DPYTHONQT_USE_RELEASE_PYTHON_FALLBACK)
-  set(PYTHONQT_FOUND 1)
-  set(PythonQt_FOUND ${PYTHONQT_FOUND})
-  set(PYTHONQT_LIBRARIES ${PYTHONQT_LIBRARY} ${PYTHONQT_LIBUTIL} ${PYTHONQT_QTALL_LIBRARY})
-  set(PYTHONQT_INCLUDE_DIRS ${PYTHONQT_INCLUDE_DIR})
-  if(PYTHONQT_ALL_INCLUDE_DIR)
-    list(APPEND PYTHONQT_INCLUDE_DIRS ${PYTHONQT_ALL_INCLUDE_DIR})
-  endif()
-elseif(NOT PythonQt_FIND_QUIETLY)
-  set(_missing "")
-  if (NOT PYTHONQT_INCLUDE_DIR)
-    list(APPEND _missing "includes")
-  endif()
-  if (NOT PYTHONQT_LIBRARY)
-    list(APPEND _missing "library")
-  endif()
-  if (NOT PYTHONQT_QTALL_LIBRARY)
-    list(APPEND _missing "qtall")
-  endif()
-  message(STATUS "PythonQt not found, missing components ${_missing}")
-endif()

CMakeModules/FindYAMLCPP.cmake

@@ -13,7 +13,7 @@
 #   YAMLCPP_LIBRARY, where to find yaml-cpp
 #   YAMLCPP_INCLUDE_DIR, where to find yaml.h
 # There is also one IMPORTED library target,
-#   yamlcpp
+#   yamlcpp::yamlcpp
 #
 # By default, the dynamic libraries of yaml-cpp will be found. To find the static ones instead,
 # you must set the YAMLCPP_STATIC_LIBRARY variable to TRUE before calling find_package(YamlCpp ...).
@@ -21,6 +21,10 @@
 # If yaml-cpp is not installed in a standard path, you can use the YAMLCPP_DIR CMake variable
 # to tell CMake where yaml-cpp is.
 
+if(TARGET yamlcpp::yamlcpp)
+    return()
+endif()
+
 # attempt to find static library first if this is set
 if(YAMLCPP_STATIC_LIBRARY)
     set(YAMLCPP_STATIC libyaml-cpp.a)
@@ -61,9 +65,9 @@ mark_as_advanced(YAMLCPP_INCLUDE_DIR YAMLCPP_LIBRARY)
 
 # Add an imported target
 if( YAMLCPP_LIBRARY )
-    add_library( yamlcpp UNKNOWN IMPORTED )
-    set_property( TARGET yamlcpp PROPERTY IMPORTED_LOCATION ${YAMLCPP_LIBRARY} )
+    add_library( yamlcpp::yamlcpp UNKNOWN IMPORTED )
+    set_property( TARGET yamlcpp::yamlcpp PROPERTY IMPORTED_LOCATION ${YAMLCPP_LIBRARY} )
     if ( YAMLCPP_INCLUDE_DIR )
-        set_property( TARGET yamlcpp PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${YAMLCPP_INCLUDE_DIR} )
+        set_property( TARGET yamlcpp::yamlcpp PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${YAMLCPP_INCLUDE_DIR} )
     endif()
 endif()

CMakeModules/KPMcoreHelper.cmake

@@ -7,33 +7,56 @@
 #
 # Finds KPMcore and consistently sets API flags based on the version.
 #
-if ( NOT KPMcore_searched_for )
-    set( KPMcore_searched_for TRUE )
+# If KPMcore is not found, still create calamares::kpmcore interface
+# library, which will add definition WITHOUT_KPMcore.
+#
+if(NOT TARGET calapmcore)
+    find_package(${kfname}Config CONFIG)
+    find_package(${kfname}I18n CONFIG)
+    find_package(${kfname}WidgetsAddons CONFIG)
 
-    find_package( KPMcore 3.3 )
-    set_package_properties(
-        KPMcore PROPERTIES
-        URL "https://invent.kde.org/kde/kpmcore"
-        DESCRIPTION "KDE Partitioning library"
-        TYPE RECOMMENDED
-        PURPOSE "For disk partitioning support"
-    )
+    if(NOT WITH_QT6)
+        # TODO: Qt6 how to detect the version of Qt that KPMCore needs?
+        find_package(KPMcore 20.04.0)
+        set_package_properties(
+            KPMcore
+            PROPERTIES
+            URL "https://invent.kde.org/kde/kpmcore"
+            DESCRIPTION "KDE Partitioning library"
+            TYPE RECOMMENDED
+            PURPOSE "For disk partitioning support"
+        )
+    endif()
 
-    if( KPMcore_FOUND )
-        set( KPMcore_API_DEFINITIONS "" )
-        if( KPMcore_VERSION VERSION_GREATER "3.3.70" AND KPMcore_VERSION VERSION_LESS "4.0" )
-            message( FATAL_ERROR "KPMCore beta versions ${KPMcore_VERSION} not supported" )
-        endif()
-        if ( KPMcore_VERSION VERSION_GREATER "3.3.0")
-            list( APPEND KPMcore_API_DEFINITIONS WITH_KPMCORE331API) # kpmcore > 3.3.0 with deprecations
-        endif()
-        if ( KPMcore_VERSION VERSION_GREATER_EQUAL "4.0")
-            list( APPEND KPMcore_API_DEFINITIONS WITH_KPMCORE4API) # kpmcore 4 with new API
-        endif()
-        if( KPMcore_VERSION VERSION_GREATER_EQUAL "4.2" )
-            list( APPEND KPMcore_API_DEFINITIONS WITH_KPMCORE42API) # kpmcore 4.2 with new API
-        endif()
+    # Create an internal Calamares interface to KPMcore
+    # and give it a nice alias name. If kpmcore is not found,
+    # then make a "no KPMcore" library.
+    add_library(calapmcore INTERFACE)
+
+    if(KPMcore_FOUND)
+        find_package(${qtname} REQUIRED DBus) # Needed for KPMCore
+        find_package(${kfname} REQUIRED I18n WidgetsAddons) # Needed for KPMCore
+
+        target_link_libraries(calapmcore INTERFACE kpmcore ${qtname}::DBus ${kfname}::I18n ${kfname}::WidgetsAddons)
+        target_include_directories(calapmcore INTERFACE ${KPMCORE_INCLUDE_DIR})
+        # If there were KPMcore API variations, figure them out here
+        # target_compile_definitions(calapmcore INTERFACE WITH_KPMcore)
+
+        # Flag that this library has KPMcore support. A variable
+        # set here has the wrong scope. ENV{} would be visible
+        # everywhere but seems the wrong thing to do. Setting
+        # properties on calapmcore requires a newer CMake than
+        # Debian 11 has, so runs into support issues.
+        add_library(calamares::kpmcore ALIAS calapmcore)
     else()
-        set( KPMcore_API_DEFINITIONS WITHOUT_KPMcore )
+        target_compile_definitions(calapmcore INTERFACE WITHOUT_KPMcore)
+    endif()
+else()
+    if(TARGET calamares::kpmcore)
+        message(STATUS "KPMcore has already been found")
+        set(KPMcore_FOUND TRUE)
+    else()
+        message(STATUS "KPMcore has been searched-for and not found")
+        set(KPMcore_FOUND FALSE)
     endif()
 endif()

CONTRIBUTING.md

@@ -28,14 +28,18 @@ rules of decent behavior in both communities are pretty much the same).
 
 GitHub Issues are **one** place for discussing Calamares if there are concrete
 problems or a new feature to discuss.
+Issues are not a help channel.
+Visit Matrix for help with configuration or compilation.
 
-Regular Calamares development chit-chat happens on old-school IRC
-(no registration required). Responsiveness is best during the day
-in Europe, but feel free to idle. **DO NOT** ask-and-leave. Keep
-that chat window open because it can easily take a few hours for
-someone to notice a message.
+Regular Calamares development chit-chat happens in a [Matrix](https://matrix.org/)
+room, `#calamares:kde.org`. Responsiveness is best during the day
+in Europe, but feel free to idle.
+Matrix is persistent, and we'll see your message eventually.
 
-[![Visit our IRC channel](https://kiwiirc.com/buttons/webchat.freenode.net/calamares.png)](https://webchat.freenode.net/?channel=#calamares?nick=guest)
+**Note:** You need an account to access Matrix. It doesn't have to be a KDE account,
+it can be on any Matrix homeserver.
+
+* [![Join us on Matrix](https://img.shields.io/badge/Matrix-%23calamares:kde.org-blue)](https://webchat.kde.org/#/room/%23calamares:kde.org)
 
 
 ## General Guidelines
@@ -53,7 +57,7 @@ stay that way.
 
 If you are writing documentation, use *en_US* spelling.
 
-If you are doing cool stuff, let us know (on IRC or through issues).
+If you are doing cool stuff, let us know (on Matrix or through issues).
 
 **Do** fork Calamares to try new things, **don't** keep your fork to
 yourself, **do** upstream things as much as you can. When you make cool
@@ -70,26 +74,71 @@ Up to date
 [building-Calamares](https://github.com/calamares/calamares/wiki/Develop-Guide)
 instructions are on the wiki.
 
-### Dependencies
+### Simple Build in Docker
+
+You may have success with the Docker images that the CI system uses.
+Pick one (or more) of these images which are also used in CI:
+- `docker pull docker://opensuse/tumbleweed`
+- `docker pull kdeneon/plasma:user`
+- `docker pull fedora:38`
+
+Then start a container with the right image, from the root of Calamares
+source checkout. Start with this command and substitute `opensuse/tumbleweed`
+or `kdeneon/plasma:user` for the `$IMAGE` part.
+
+```
+docker run -ti \
+    --tmpfs /build:rw,exec \
+    --user 0:0 \
+    -e DISPLAY=:0 \
+    -v /tmp/.X11-unix:/tmp/.X11-unix \
+    -v .:/src \
+    $IMAGE \
+    bash
+```
+
+This starts a container with the chosen image with a temporary build
+directory in `/build` and the Calamaressources mounted as `/src`.
+
+Run the script to install dependencies: you could use `deploycala.py`
+or one of the shell scripts in `ci/` to install the right
+dependencies for the image (in this example, for openSUSE and Qt6).
+- `cd /src`
+- `./ci/deps-opensuse-qt6.sh`
+
+Then run CMake (add any CMake options you like at the end) and ninja.
+There is a script `ci/build.sh` that does this, too (without options).
+- `cmake -S /src -B /build -G Ninja`
+- `ninja -C /build`
+
+To run Calamares inside the container, or e.g. `loadmodule` to test
+individual modules, you may need to configure X authentication; a
+simple and insecure way of doing that is to run `xhost +` in the host
+environment of the Docker containers.
+
+### Dependencies for Calamares 3.3
+
+> The dependencies for Calamares 3.3 reflect "resonably current"
+> software as of September 2023. For Calamares 3.2 dependencies,
+> which are 2017-era, see the `CONTRIBUTING` file in that branch.
 
 Main:
-* Compiler with C++17 support: GCC >= 7 or Clang >= 5
-* CMake >= 3.3
-* Qt >= 5.9
+* Compiler with C++17 support
+* CMake >= 3.16
 * yaml-cpp >= 0.5.1
-* Python >= 3.3 (required for some modules)
-* Boost.Python >= 1.55.0 (required for some modules)
-* KDE extra-cmake-modules >= 5.18 (recommended; required for some modules;
+* Qt >= 5.15 or Qt >= 6.5
+* KDE Frameworks KCoreAddons >= 5.78
+* KDE extra-cmake-modules >= 5.78 (recommended; required for some modules;
   required for some tests)
-* KDE Frameworks KCoreAddons (>= 5.58 recommended)
-* PythonQt (optional, deprecated)
+* Python >= 3.6 (required for some modules)
+* Boost.Python >= 1.72.0 (required for some modules)
 
 Individual modules may have their own requirements;
 these are listed in CMake output.
 Particular requirements (not complete):
 
-* *fsresizer* KPMCore >= 3.3 (>= 4.2 recommended)
-* *partition* KPMCore >= 3.3 (>= 4.2 recommended)
+* *fsresizer* KPMCore >= 20.04
+* *partition* KPMCore >= 20.04
 * *users* LibPWQuality (optional)
 
 

CalamaresConfig.cmake.in

@@ -23,6 +23,12 @@
 #
 include(${CMAKE_CURRENT_LIST_DIR}/CalamaresConfigVersion.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/CalamaresTargets.cmake)
+if (NOT TARGET Calamares::calamares OR NOT TARGET Calamares::calamaresui)
+    message(FATAL_ERROR "Calamares found with missing CMake targets")
+endif()
+
+# Need various CMake files that are installed alongside this one.
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
 
 ### Dependencies
 #
@@ -40,23 +46,32 @@ macro(accumulate_deps outvar target namespace)
     endforeach()
 endmacro()
 
-# Qt5 infrastructure for translations is required
-set(qt5_required Core Widgets LinguistTools)
-accumulate_deps(qt5_required Calamares::calamares Qt5::)
-accumulate_deps(qt5_required Calamares::calamaresui Qt5::)
-find_package(Qt5 CONFIG REQUIRED ${qt5_required})
+set(Calamares_WITH_QT6 @WITH_QT6@)
+if(Calamares_WITH_QT6)
+    set(qtname "Qt6")
+else()
+    set(qtname "Qt5")
+endif()
+
+# Qt infrastructure for translations is required
+set(qt_required Core Widgets LinguistTools)
+accumulate_deps(qt_required Calamares::calamares ${qtname}::)
+accumulate_deps(qt_required Calamares::calamaresui ${qtname}::)
+find_package(${qtname} CONFIG REQUIRED ${qt_required})
 
 set(kf5_required "")
-accumulate_deps(kf5_required Calamares::calamares KF5::)
-accumulate_deps(kf5_required Calamares::calamaresui KF5::)
+accumulate_deps(kf5_required Calamares::calamares ${kfname}::)
+accumulate_deps(kf5_required Calamares::calamaresui ${kfname}::)
 if(kf5_required)
     find_package(ECM ${ECM_VERSION} NO_MODULE)
     if( ECM_FOUND )
-        list(PREPEND CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
-        find_package(KF5 REQUIRED COMPONENTS ${kf5_required})
+        list(INSERT CMAKE_MODULE_PATH 0 ${ECM_MODULE_PATH})
+        find_package(${kfname} REQUIRED COMPONENTS ${kf5_required})
     endif()
 endif()
 
+find_package(YAMLCPP REQUIRED)
+
 ### Legacy support
 #
 #
@@ -67,8 +82,6 @@ set(Calamares_LIBRARIES Calamares::calamares)
 ### CMake support
 #
 #
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
-
 include(CalamaresAddBrandingSubdirectory)
 include(CalamaresAddLibrary)
 include(CalamaresAddModuleSubdirectory)
@@ -81,5 +94,4 @@ include(CalamaresAddPlugin)
 # This list should match the one in libcalamares/CalamaresConfig.h,
 # which is the C++-language side of the same configuration.
 set(Calamares_WITH_PYTHON @WITH_PYTHON@)
-set(Calamares_WITH_PYTHONQT @WITH_PYTHONQT@)
 set(Calamares_WITH_QML @WITH_QML@)

Dockerfile

@@ -1,5 +0,0 @@
-#   SPDX-FileCopyrightText: 2017 Rohan Garg <rohan@garg.io>
-#   SPDX-License-Identifier: BSD-2-Clause
-
-FROM kdeneon/all:user
-RUN sudo apt-get update && sudo apt-get -y install build-essential cmake extra-cmake-modules gettext kio-dev libatasmart-dev libboost-python-dev libkf5config-dev libkf5coreaddons-dev libkf5i18n-dev libkf5iconthemes-dev libkf5parts-dev libkf5service-dev libkf5solid-dev libkpmcore-dev libparted-dev libpolkit-qt5-1-dev libqt5svg5-dev libqt5webkit5-dev libyaml-cpp-dev os-prober pkg-config python3-dev qtbase5-dev qtdeclarative5-dev qttools5-dev qttools5-dev-tools

LICENSES/LGPL-2.0-only.txt

@@ -1,488 +0,0 @@
-
- The KD Tools Library is Copyright (C) 2001-2010 Klaralvdalens Datakonsult AB.
-
- You may use, distribute and copy the KD Tools Library under the terms of
- GNU Library General Public License version 2, which is displayed below.
-
--------------------------------------------------------------------------
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-                  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

README.md

@@ -5,30 +5,30 @@
 # Calamares: Distribution-Independent Installer Framework
 ---------
 
+[![Current issue](https://img.shields.io/badge/issue-in_progress-FE9B48)](https://github.com/calamares/calamares/labels/hacking%3A%20in-progress)
 [![GitHub release](https://img.shields.io/github/release/calamares/calamares.svg)](https://github.com/calamares/calamares/releases)
-[![Travis Build Status](https://travis-ci.org/calamares/calamares.svg?branch=calamares)](https://travis-ci.org/calamares/calamares)
-[![Coverity Scan Build Status](https://scan.coverity.com/projects/5389/badge.svg)](https://scan.coverity.com/projects/5389)
-[![GitHub license](https://img.shields.io/github/license/calamares/calamares.svg)](https://github.com/calamares/calamares/blob/calamares/LICENSE)
+[![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/calamares/calamares/push.yml)](https://github.com/calamares/calamares/actions?query=workflow%3Aci)
+[![GitHub license](https://img.shields.io/badge/license-Multiple-green)](https://github.com/calamares/calamares/tree/calamares/LICENSES)
 
 
-| [Report a Bug](https://github.com/calamares/calamares/issues/new) | [Translate](https://www.transifex.com/projects/p/calamares/) | [Contribute](CONTRIBUTING.md) | [Freenode (IRC): #calamares](https://webchat.freenode.net/?channel=#calamares?nick=guest) | [Wiki](https://github.com/calamares/calamares/wiki) |
+| [Report a Bug](https://github.com/calamares/calamares/issues/new) | [Translate](https://app.transifex.com/calamares/calamares/) | [Contribute](CONTRIBUTING.md) | [Chat on Matrix: #calamares:kde.org](https://webchat.kde.org/#/room/%23calamares:kde.org) | [Wiki](https://github.com/calamares/calamares/wiki) |
 |:--:|:--:|:--:|:--:|:--:|
 
 
 > Calamares is a distribution-independent system installer, with an advanced partitioning
 > feature for both manual and automated partitioning operations. Calamares is designed to
-> be customizable by distribution maintainers without need for cumbersome patching,
-> thanks to third party branding and external modules support.
+> be customizable by distribution maintainers without the need for cumbersome patching,
+> thanks to third-party branding and external modules support.
 
 ## Target Audience
 
 Calamares is a Linux installer; users who install Linux on a computer will hopefully
 use it just **once**, to install their Linux distribution. Calamares is not
-a "ready to use" application: distributions apply a huge amount of customisation
+a "ready to use" application: distributions apply a huge amount of customization
 and configuration to Calamares, and the target audience for this repository
-is those distributions, and the people who make those Linux distro's.
+is those distributions, and the people who make those Linux distros.
 
-Calamares has some [generic user documentation](https://github.com/calamares/calamares/wiki/Use-Guide)
+Calamares has some [generic user documentation](https://calamares.io/docs/users-guide/)
 for end-users, but most of what we have is for distro developers.
 
 ## Getting Calamares
@@ -45,19 +45,23 @@ The dependencies are explained in [CONTRIBUTING.md](CONTRIBUTING.md).
 ## Contributing to Calamares
 
 Calamares welcomes PRs. New issues are welcome, too.
-There are both the Calamares **core** repository (this one),
-and an *extensions** repository ([Calamares extensions](https://github.com/calamares/calamares-extensions).
+There are both the Calamares **core** repository (this one)
+and an **extensions** repository ([Calamares extensions](https://github.com/calamares/calamares-extensions)).
 
-Contributions to code, modules, documentation, the wiki and the website are all welcome.
+Contributions to code, modules, documentation, the wiki, and the website are all welcome.
 There is more information in the [CONTRIBUTING.md](CONTRIBUTING.md) file.
 
 ## Join the Conversation
 
 GitHub Issues are **one** place for discussing Calamares if there are concrete
 problems or a new feature to discuss.
+Issues are not a help channel.
+Visit Matrix for help with configuration or compilation.
 
-Regular Calamares development chit-chat happens on old-school IRC
-(no registration required). Responsiveness is best during the day
+Regular Calamares development chit-chat happens in a [Matrix](https://matrix.org/)
+room, `#calamares:kde.org`. Responsiveness is best during the day
 in Europe, but feel free to idle.
+Matrix is persistent, and we'll see your message eventually.
+
+* [![Join us on Matrix](https://img.shields.io/badge/Matrix-%23calamares:kde.org-blue)](https://webchat.kde.org/#/room/%23calamares:kde.org) (needs a Matrix account)
 
-[![Visit our IRC channel](https://kiwiirc.com/buttons/webchat.freenode.net/calamares.png)](https://webchat.freenode.net/?channel=#calamares?nick=guest|)

calamares.desktop

@@ -5,7 +5,7 @@ Name=Install System
 GenericName=System Installer
 Keywords=calamares;system;installer;
 TryExec=calamares
-Exec=pkexec /usr/bin/calamares
+Exec=sh -c "pkexec calamares"
 Comment=Calamares — System Installer
 Icon=calamares
 Terminal=false
@@ -21,18 +21,26 @@ Name[as]=চিছটেম ইনস্তল কৰক
 Icon[as]=কেলামাৰেচ
 GenericName[as]=চিছটেম ইনস্তলাৰ
 Comment[as]=কেলামাৰেচ — চিছটেম​ ইনস্তলাৰ
+Name[ast]=Instalar el sistema
+Icon[ast]=calamares
+GenericName[ast]=Instalador del sistema
+Comment[ast]=Calamares — Instalador del sistema
 Name[az]=Sistemi Quraşdırmaq
 Icon[az]=calamares
 GenericName[az]=Sistem Quraşdırıcısı
 Comment[az]=Calamares Sistem Quraşdırıcısı
+Name[az_AZ]=Sistemi quraşdırmaq
+Icon[az_AZ]=calamares
+GenericName[az_AZ]=Sistem quraşdırcısı
+Comment[az_AZ]=Calamares — Sistem Quraşdırıcısı
 Name[be]=Усталяваць сістэму
 Icon[be]=calamares
 GenericName[be]=Усталёўшчык сістэмы
 Comment[be]=Calamares — усталёўшчык сістэмы
 Name[bg]=Инсталирай системата
 Icon[bg]=calamares
-GenericName[bg]=Системен Инсталатор
-Comment[bg]=Calamares — Системен Инсталатор
+GenericName[bg]=Системен инсталатор
+Comment[bg]=„Calamares“ – Системен инсталатор
 Name[bn]=সিস্টেম ইনস্টল করুন
 Icon[bn]=ক্যালামারেস
 GenericName[bn]=সিস্টেম ইনস্টলার
@@ -41,6 +49,10 @@ Name[ca]=Instal·la el sistema
 Icon[ca]=calamares
 GenericName[ca]=Instal·lador de sistema
 Comment[ca]=Calamares — Instal·lador de sistema
+Name[cs_CZ]=Nainstalovat systém
+Icon[cs_CZ]=calamares
+GenericName[cs_CZ]=Instalátor systému
+Comment[cs_CZ]=Calamares – instalátor operačních systémů
 Name[da]=Installér system
 Icon[da]=calamares
 GenericName[da]=Systeminstallationsprogram
@@ -57,10 +69,19 @@ Name[en_GB]=Install System
 Icon[en_GB]=calamares
 GenericName[en_GB]=System Installer
 Comment[en_GB]=Calamares — System Installer
-Name[es]=Instalar Sistema
+Name[eo]=Instali Sistemo
+Icon[eo]=calamares
+GenericName[eo]=Sistema Instalilo
+Comment[eo]=Calamares — Sistema Instalilo
+Name[es]=Instalar el sistema
 Icon[es]=calamares
-GenericName[es]=Instalador del Sistema
-Comment[es]=Calamares — Instalador del Sistema
+GenericName[es]=Instalador del sistema
+Comment[es]=Calamares — Instalador del sistema
+Name[es_MX]=Instalar el Sistema
+Icon[es_MX]=calamares
+GenericName[es_MX]=Instalador del sistema
+Comment[es_MX]=Calamares - Instalador del sistema
+Name[es_PR]=Instalar el sistema
 Name[et]=Paigalda süsteem
 Icon[et]=calamares
 GenericName[et]=Süsteemipaigaldaja
@@ -71,9 +92,12 @@ GenericName[eu]=Sistema instalatzailea
 Comment[eu]=Calamares - sistema instalatzailea
 Name[fa]=نصب سامانه
 Icon[fa]=کالامارس
-GenericName[fa]=نصب‌کنندهٔ سامانه
-Comment[fa]=کالامارس — نصب‌کنندهٔ سامانه
-Name[es_PR]=Instalar el sistema
+GenericName[fa]=نصب‌کننده سامانه
+Comment[fa]=کالامارس — نصب‌کننده سامانه
+Name[fi_FI]=Asenna järjestelmä
+Icon[fi_FI]=calamares
+GenericName[fi_FI]=Järjestelmän asennusohjelma
+Comment[fi_FI]=Calamares — Järjestelmän asentaja
 Name[fr]=Installer le système
 Icon[fr]=calamares
 GenericName[fr]=Installateur système
@@ -98,10 +122,6 @@ Name[hr]=Instaliraj sustav
 Icon[hr]=calamares
 GenericName[hr]=Instalacija sustava
 Comment[hr]=Calamares — Instalacija sustava
-Name[ie]=Installar li sistema
-Icon[ie]=calamares
-GenericName[ie]=Installator del sistema
-Comment[ie]=Calamares — Installator del sistema
 Name[hu]=Rendszer telepítése
 Icon[hu]=calamares
 GenericName[hu]=Rendszertelepítő
@@ -110,14 +130,18 @@ Name[id]=Instal Sistem
 Icon[id]=calamares
 GenericName[id]=Pemasang
 Comment[id]=Calamares — Pemasang Sistem
+Name[ie]=Installar li sistema
+Icon[ie]=calamares
+GenericName[ie]=Installator del sistema
+Comment[ie]=Calamares — Installator del sistema
 Name[is]=Setja upp kerfið
 Icon[is]=calamares
 GenericName[is]=Kerfis uppsetning
 Comment[is]=Calamares — Kerfis uppsetning
-Name[cs_CZ]=Nainstalovat systém
-Icon[cs_CZ]=calamares
-GenericName[cs_CZ]=Instalátor systému
-Comment[cs_CZ]=Calamares – instalátor operačních systémů
+Name[it_IT]=Installa il sistema
+Icon[it_IT]=calamares
+GenericName[it_IT]=Programma d'installazione del sistema
+Comment[it_IT]=Calamares — Programma d'installazione del sistema
 Name[ja]=システムをインストール
 Icon[ja]=calamares
 GenericName[ja]=システムインストーラー
@@ -130,10 +154,6 @@ Name[lt]=Įdiegti Sistemą
 Icon[lt]=calamares
 GenericName[lt]=Sistemos diegimas į kompiuterį
 Comment[lt]=Calamares — Sistemos diegimo programa
-Name[it_IT]=Installa il sistema
-Icon[it_IT]=calamares
-GenericName[it_IT]=Programma d'installazione del sistema
-Comment[it_IT]=Calamares — Programma d'installazione del sistema
 Name[mk]=Инсталирај го системот
 Icon[mk]=calamares
 GenericName[mk]=Системен Инсталер
@@ -146,14 +166,14 @@ Name[nb]=Installer System
 Icon[nb]=calamares
 GenericName[nb]=Systeminstallatør
 Comment[nb]=Calamares-systeminstallatør
+Name[ne_NP]= सिस्टम इन्स्टल गर्नुहोस्
+Icon[ne_NP]=Calamares
+GenericName[ne_NP]=सिस्टम इन्स्टलर
+Comment[ne_NP]=Calamares - सिस्टम इन्स्टलर
 Name[nl]=Installeer systeem
 Icon[nl]=calamares
 GenericName[nl]=Installatieprogramma
 Comment[nl]=Calamares — Installatieprogramma
-Name[az_AZ]=Sistemi quraşdırmaq
-Icon[az_AZ]=calamares
-GenericName[az_AZ]=Sistem quraşdırcısı
-Comment[az_AZ]=Calamares — Sistem Quraşdırıcısı
 Name[pl]=Zainstaluj system
 Icon[pl]=calamares
 GenericName[pl]=Instalator systemu
@@ -162,6 +182,10 @@ Name[pt_BR]=Sistema de Instalação
 Icon[pt_BR]=calamares
 GenericName[pt_BR]=Instalador de Sistema
 Comment[pt_BR]=Calamares — Instalador de Sistema
+Name[pt_PT]=Instalar Sistema
+Icon[pt_PT]=calamares
+GenericName[pt_PT]=Instalador de Sistema
+Comment[pt_PT]=Instalador de Sistema - Calamares
 Name[ro]=Instalează sistemul
 Icon[ro]=calamares
 GenericName[ro]=Instalator de sistem
@@ -170,6 +194,10 @@ Name[ru]=Установить систему
 Icon[ru]=calamares
 GenericName[ru]=Установщик системы
 Comment[ru]=Calamares - Установщик системы
+Name[si]=පද්ධතිය ස්ථාපනය කරන්න
+Icon[si]=කැලමරේස්
+GenericName[si]=පද්ධති ස්ථාපකය
+Comment[si]=Calamares - පද්ධති ස්ථාපකය
 Name[sk]=Inštalovať systém
 Icon[sk]=calamares
 GenericName[sk]=Inštalátor systému
@@ -179,15 +207,11 @@ Name[sq]=Instalo Sistemin
 Icon[sq]=calamares
 GenericName[sq]=Instalues Sistemi
 Comment[sq]=Calamares — Instalues Sistemi
-Name[fi_FI]=Asenna Järjestelmä
-Icon[fi_FI]=calamares
-GenericName[fi_FI]=Järjestelmän Asennusohjelma
-Comment[fi_FI]=Calamares — Järjestelmän Asentaja
-Name[sr@latin]=Instaliraj sistem
 Name[sr]=Инсталирај систем
 Icon[sr]=calamares
 GenericName[sr]=Инсталатер система
 Comment[sr]=Каламарес — инсталатер система
+Name[sr@latin]=Instaliraj sistem
 Name[sv]=Installera system
 Icon[sv]=calamares
 GenericName[sv]=Systeminstallerare
@@ -197,6 +221,10 @@ Icon[tg]=calamares
 GenericName[tg]=Насбкунандаи низомӣ
 Comment[tg]=Calamares — Насбкунандаи низомӣ
 Name[th]=ติดตั้งระบบ
+Name[tr_TR]=Sistemi Yükle
+Icon[tr_TR]=calamares
+GenericName[tr_TR]=Sistem Yükleyici
+Comment[tr_TR]=Calamares — Sistem Yükleyici
 Name[uk]=Встановити Систему
 Icon[uk]=calamares
 GenericName[uk]=Встановлювач системи
@@ -213,27 +241,3 @@ Name[zh_TW]=安裝系統
 Icon[zh_TW]=calamares
 GenericName[zh_TW]=系統安裝程式
 Comment[zh_TW]=Calamares ── 系統安裝程式
-Name[ast]=Instalar el sistema
-Icon[ast]=calamares
-GenericName[ast]=Instalador del sistema
-Comment[ast]=Calamares — Instalador del sistema
-Name[eo]=Instali Sistemo
-Icon[eo]=calamares
-GenericName[eo]=Sistema Instalilo
-Comment[eo]=Calamares — Sistema Instalilo
-Name[ne_NP]= सिस्टम इन्स्टल गर्नुहोस्
-Icon[ne_NP]=Calamares
-GenericName[ne_NP]=सिस्टम इन्स्टलर
-Comment[ne_NP]=Calamares - सिस्टम इन्स्टलर
-Name[es_MX]=Instalar el Sistema
-Icon[es_MX]=calamares
-GenericName[es_MX]=Instalador del sistema
-Comment[es_MX]=Calamares - Instalador del sistema
-Name[pt_PT]=Instalar Sistema
-Icon[pt_PT]=calamares
-GenericName[pt_PT]=Instalador de Sistema
-Comment[pt_PT]=Calamares - Instalador de Sistema
-Name[tr_TR]=Sistemi Yükle
-Icon[tr_TR]=calamares
-GenericName[tr_TR]=Sistem Yükleyici
-Comment[tr_TR]=Calamares — Sistem Yükleyici

calamares.desktop.in

@@ -5,7 +5,7 @@ Name=Install System
 GenericName=System Installer
 Keywords=calamares;system;installer;
 TryExec=calamares
-Exec=pkexec /usr/bin/calamares
+Exec=sh -c "pkexec calamares"
 Comment=Calamares — System Installer
 Icon=calamares
 Terminal=false

ci/RELEASE.md

@@ -11,8 +11,31 @@
 >
 > Most things are automated through the release script [RELEASE.sh](RELEASE.sh)
 
+## (0) During a release cycle
+
+* Fetch latest translations from Transifex. We only push / pull translations
+  from *calamares* branch, so longer-lived branches (e.g. 3.1.x) don't get
+  translation updates. This is to keep the translation workflow simple.
+  The script automatically commits changes to the translations. It's ok
+  to do this during a release cycle. Run `sh ci/txpull.sh`
+  to fetch translations and commit the changes in one go.
+* Push the strings to Transifex. From a checkout, run `ci/txpush.sh`
+* Update the list of enabled translation languages in `CMakeLists.txt`.
+  Check the [translation site][transifex] for the list of languages with
+  fairly complete translations, or use `ci/txstats.py --edit` for an automated
+  suggestion. If there are changes, commit them.
+
 ## (1) Preparation
 
+* Double-check the *CALAMARES_VERSION* value at the top of `CMakeLists.txt`.
+* Set *CALAMARES_RELEASE_MODE* to `ON` in `CMakeLists.txt`.
+* Edit `CHANGES-*` and set the date of the release. Pick the right
+  file for the release-stream.
+* Commit both. This is usually done with commit-message
+  *Changes: pre-release housekeeping*.
+
+## (2) Release Preparation
+
 * Make sure all tests pass.
   ```
     make
@@ -22,27 +45,16 @@
   an additional environment variable to be set for some tests, which will
   destroy an attached disk. This is not always desirable. There are some
   sample config-files that are empty and which fail the config-tests.
-* Pull latest translations from Transifex. We only push / pull translations
-  from master, so longer-lived branches (e.g. 3.1.x) don't get translation
-  updates. This is to keep the translation workflow simple. The script
-  automatically commits changes to the translations.
-  ```
-    sh ci/txpull.sh
-  ```
-* Update the list of enabled translation languages in `CMakeLists.txt`.
-  Check the [translation site][transifex] for the list of languages with
-  fairly complete translations, or use `ci/txstats.py` for an automated
-  suggestion. If there are changes, commit them.
-* Push the changes.
-* Check defaults in `settings.conf` and other configuration files.
-* Drop the RC variable to 0 in `CMakeLists.txt`, *CALAMARES_VERSION_RC*.
-* Edit `CHANGES` and set the date of the release.
-* Commit both. This is usually done with commit-message
-  *Changes: pre-release housekeeping*.
-
-
-## (2) Release Day
-
+  Note that the release script (see below) also runs the tests and
+  will bail out if any fail.
+* Make sure the translations are up-to-date. There is logic to check
+  for changes in translations: a movable tag *translations* indicates
+  when translations were last pushed, and the logic tries to enforce a
+  week of latency between push-translations and a release, to allow
+  translators to catch up. Run `ci/txcheck.sh` to confirm this.
+  Run `ci/txcheck.sh --cleanup` to tidy up afterwards, and possibly pass
+  `-T` to the release script to skip the translation-age check if you
+  feel it is warranted.
 * Run the helper script `ci/RELEASE.sh` or follow steps below.
   The script checks:
   - for uncommitted local changes,
@@ -64,30 +76,18 @@ Follow the instructions printed by the release script.
 * Upload tarball and signature.
 * Publish release article on `calamares.io`.
 * Close associated milestone on GitHub if it's entirely done.
-* Update topic on #calamares IRC channel.
+* Update topic on `#calamares:kde.org` Matrix channel.
 
 ## (4) Post-Release
 
-* Bump the version number in `CMakeLists.txt` in the `project()` command.
-* Set *CALAMARES_VERSION_RC* back to 1.
-* Add a placeholder entry for the next release in `CHANGES` with date
-  text *not released yet*.
+* Bump the version number in `CMakeLists.txt` in *CALAMARES_VERSION*.
+* Set *CALAMARES_RELEASE_MODE* back to `OFF`.
+* Add a placeholder entry for the next release in `CHANGES-*` with date
+  text *not released yet*. See the text below, "Placeholder Release".
+  Add the placeholder to the right file for the release-stream.
 * Commit and push that, usually with the message
   *Changes: post-release housekeeping*.
 
-```
-# 3.2.XX (unreleased) #
-
-This release contains contributions from (alphabetically by first name):
- - No external contributors yet
-
-## Core ##
- - No core changes yet
-
-## Modules ##
- - No module changes yet
-```
-
 # Related Material
 
 > This section isn't directly related to any specific release,
@@ -119,7 +119,7 @@ ssb  rsa3072/0xCFDDC96F12B1915C
   the Calmares site or as part of a release announcement).
   - Send the updated key to keyservers with `gpg --send-keys <keyid>`
   - Optional: sanitize the keyring for use in development machines.
-    Export the current subkeys of the master key and keep **only** those
+    Export the current subkeys of the primary key and keep **only** those
     secret keys around. There is documentation
     [here](https://blog.tinned-software.net/create-gnupg-key-with-sub-keys-to-sign-encrypt-authenticate/)
     but be careful.
@@ -128,3 +128,18 @@ ssb  rsa3072/0xCFDDC96F12B1915C
   - Upload that public key to the relevant GitHub profile.
   - Upload that public key to the Calamares site.
 
+## Placeholder Release Notes
+
+```
+# 3.2.XX (unreleased) #
+
+This release contains contributions from (alphabetically by first name):
+ - No external contributors yet
+
+## Core ##
+ - No core changes yet
+
+## Modules ##
+ - No module changes yet
+```
+

ci/RELEASE.sh

@@ -27,11 +27,13 @@
 #   * `-B` do not build (before tagging)
 #   * `-P` do not package (tag, sign, tarball)
 #   * `-T` do not respect string freeze
+#   * '-b' do not build-and-test tarball
 #
 # The build / package settings can be influenced via environment variables:
 #   * BUILD_DEFAULT set to `false` to avoid first build with gcc
 #   * BUILD_CLANG   set to `false` to avoid second build with clang
 #   * BUILD_ONLY    set to `true` to break after building
+#   * TEST_TARBALL  set to 'false' to skip build-and-test phase after tarring
 #
 ### END USAGE
 
@@ -43,9 +45,10 @@ which cmake > /dev/null 2>&1 || { echo "No cmake(1) available." ; exit 1 ; }
 test -z "$BUILD_DEFAULT" && BUILD_DEFAULT=true
 test -z "$BUILD_CLANG" && BUILD_CLANG=true
 test -z "$BUILD_ONLY" && BUILD_ONLY=false
+test -z "$TEST_TARBALL" && TEST_TARBALL=true
 STRING_FREEZE=true
 
-while getopts "hBPT" opt ; do
+while getopts "hBbPT" opt ; do
     case "$opt" in
     h|\?)
         sed -e '1,/USAGE/d' -e '/END.USAGE/,$d' < "$0"
@@ -55,6 +58,9 @@ while getopts "hBPT" opt ; do
         BUILD_DEFAULT=false
         BUILD_CLANG=false
         ;;
+    b)
+	TEST_TARBALL=false
+	;;
     P)
         BUILD_ONLY=true
         ;;
@@ -72,7 +78,23 @@ fi
 ### Setup
 #
 #
-BUILDDIR=$(mktemp -d --suffix=-build --tmpdir=.)
+BUILDDIR=$(mktemp -d ./cala-tmp-XXXXXX)
+KEY_ID="328D742D8807A435"
+
+# Try to make gpg cache the signing key, so we can leave the process
+# to run and sign.
+rm -f CMakeLists.txt.gpg
+gpg -s -u $KEY_ID CMakeLists.txt
+
+### Get version number for this release
+#
+# Do this early, in a clean build-dir, since it doesn't cost much.
+# Redirect stderr from CMake script mode, because the message()
+# in CMakeLists.txt that prints the version, goes to stderr.
+rm -rf "$BUILDDIR"
+mkdir "$BUILDDIR" || { echo "Could not create build directory." ; exit 1 ; }
+V=$( cd "$BUILDDIR" && cmake -P ../CMakeLists.txt 2>&1 )
+test -n "$V" || { echo "Could not obtain version in $BUILDDIR ." ; exit 1 ; }
 
 ### Build with default compiler
 #
@@ -112,17 +134,10 @@ else
     ( cd "$BUILDDIR" && cmake .. ) || { echo "Could not run cmake in $BUILDDIR ." ; exit 1 ; }
 fi
 
-### Get version number for this release
-#
-#
-V=$( cd "$BUILDDIR" && make show-version | grep ^CALAMARES_VERSION | sed s/^[A-Z_]*=// )
-test -n "$V" || { echo "Could not obtain version in $BUILDDIR ." ; exit 1 ; }
-
 ### Create signed tag
 #
 # This is the signing key ID associated with the GitHub account adriaandegroot,
 # which is used to create all "verified" tags in the Calamares repo.
-KEY_ID="CFDDC96F12B1915C"
 git tag -u "$KEY_ID" -m "Release v$V" "v$V" || { echo "Could not sign tag v$V." ; exit 1 ; }
 
 ### Create the tarball
@@ -137,12 +152,15 @@ SHA256=$(sha256sum "$TAR_FILE" | cut -d" " -f1)
 ### Build the tarball
 #
 #
-D=$(date +%Y%m%d-%H%M%S)
-TMPDIR=$(mktemp -d --suffix="-calamares-$D")
-test -d "$TMPDIR" || { echo "Could not create tarball-build directory." ; exit 1 ; }
-tar xzf "$TAR_FILE" -C "$TMPDIR" || { echo "Could not unpack tarball." ; exit 1 ; }
-test -d "$TMPDIR/$TAR_V" || { echo "Tarball did not contain source directory." ; exit 1 ; }
-( cd "$TMPDIR/$TAR_V" && cmake . && make -j4 && make test ) || { echo "Tarball build failed in $TMPDIR ." ; exit 1 ; }
+if test "x$TEST_TARBALL" = "xtrue" ; then
+    D=$(date +%Y%m%d-%H%M%S)
+    TMPDIR=$(mktemp -d ./cala-tar-XXXXXX)
+    test -d "$TMPDIR" || { echo "Could not create tarball-build directory." ; exit 1 ; }
+    tar xzf "$TAR_FILE" -C "$TMPDIR" || { echo "Could not unpack tarball." ; exit 1 ; }
+    test -d "$TMPDIR/$TAR_V" || { echo "Tarball did not contain source directory." ; exit 1 ; }
+    ( cd "$TMPDIR/$TAR_V" && cmake . && make -j4 && make test ) || { echo "Tarball build failed in $TMPDIR ." ; exit 1 ; }
+fi
+gpg -s -u $KEY_ID --detach --armor $TAR_FILE  # Sign the tarball
 
 ### Cleanup
 #
@@ -155,7 +173,6 @@ rm -rf "$TMPDIR"  # From tarball
 cat <<EOF
 # Next steps for this release:
   git push origin v$V
-  gpg -s -u $KEY_ID --detach --armor $TAR_FILE  # Sign the tarball
   # Upload tarball $TAR_FILE and the signature $TAR_FILE.asc
   # Announce via https://github.com/calamares/calamares/releases/new
   # SHA256: $SHA256

ci/abicheck.sh

@@ -0,0 +1,74 @@
+#! /bin/sh
+#
+# SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+# SPDX-License-Identifier: BSD-2-Clause
+#
+# Compares the ABI of the current working tree with the ABI
+# from a base-version. Uses libabigail for the actual comparison.
+#
+# To use the tool, just run the script. It will build Calamares at
+# least once, maybe twice (if it needs the base-version ABI information
+# and hasn't cached it).
+
+# The base version can be a tag or git-hash; it will be checked-out
+# in a worktree.
+#
+# Note that the hash here now is 3.3-alpha1, when ABI
+# compatibility was not expected much. From 3.3-beta,
+# whenever that is, ABI compatibility should be more of a concern.
+BASE_VERSION=0c794183936b6d916a109784829e605cc4582e9f
+
+### Build a tree and cache the ABI info into ci/
+#
+#
+do_build() {
+	LABEL=$1
+	SOURCE_DIR=$2
+
+	BUILD_DIR=build-abi-$LABEL
+	rm -rf $BUILD_DIR
+	mkdir $BUILD_DIR
+
+	if ( cd $BUILD_DIR && cmake $SOURCE_DIR -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-Og -g -gdwarf" -DCMAKE_C_FLAGS="-Og -g -gdwarf" && make -j12 ) > /dev/null 2>&1
+	then
+		ls -1 $BUILD_DIR/libcalamares*.so.*
+		# Copy the un-versioned files; .so is a symlink to the just-built one
+		for lib in $BUILD_DIR/libcalamares*.so
+		do
+			cp $lib ci/`basename $lib`.$LABEL
+		done
+	else
+		echo "! failed to build $LABEL"
+		exit 1
+	fi
+}
+
+### Build current tree and get ABI info
+#
+#
+do_build current `pwd -P`
+
+### Build ABI base version
+#
+# We cache this to save on some build time, if we are chasing a
+# single branch from an unchanging base version.
+#
+if test -f ci/libcalamares.so.$BASE_VERSION
+then
+	# The ABI version is cached, so we're good
+	:
+else
+	git worktree remove --force tree-abi-$BASE_VERSION
+	git worktree add tree-abi-$BASE_VERSION $BASE_VERSION > /dev/null 2>&1 || { echo "! could not create worktree for $BASE_VERSION" ; exit 1 ; }
+	do_build $BASE_VERSION $( cd tree-abi-$BASE_VERSION && pwd -P )
+fi
+
+### Compare & Report
+#
+# abidiff compares the Application Binary Interfaces (ABI) of two
+# shared libraries in ELF format. It emits a meaningful report describing
+# the differences between the two ABIs.
+#
+# -l prints only the leaf changes, leaving out explanations of why.
+#
+abidiff -l ci/libcalamares.so.$BASE_VERSION ci/libcalamares.so.current

ci/astylerc

@@ -9,7 +9,7 @@ indent=spaces=4
 
 # Brackets
 style=break
-add-brackets
+add-braces
 
 # Spaces
 pad-paren-in

ci/build.sh

@@ -0,0 +1,20 @@
+#! /bin/sh
+#
+# Generic build (driven by environment variables)
+#
+
+# Sanity check
+test -n "$BUILDDIR" || { echo "! \$BUILDDIR not set" ; exit 1 ; }
+mkdir -p "$BUILDDIR"
+test -f "$SRCDIR/CMakeLists.txt" || { echo "! Missing $SRCDIR/CMakeLists.txt" ; exit 1 ; }
+
+BUILD_MESSAGE="No commit info"
+test -n "$GIT_HASH" && BUILD_MESSAGE=$( git log -1 --abbrev-commit --pretty=oneline --no-decorate "$GIT_HASH" )
+
+echo "::" ; echo ":: $BUILD_MESSAGE" ; echo "::"
+
+cmake -S "$SRCDIR" -B "$BUILDDIR" -G Ninja $CMAKE_ARGS || exit 1
+ninja -C "$BUILDDIR" || exit 1
+ninja -C "$BUILDDIR" install || exit 1
+
+echo "::" ; echo ":: $BUILD_MESSAGE" ; echo "::"

ci/calamaresstyle

@@ -5,12 +5,7 @@
 #   SPDX-License-Identifier: BSD-2-Clause
 #
 # Calls astyle with settings matching Calamares coding style
-# Requires astyle >= 2.04 and clang-format-7 -8 or -9
-#
-# Clang-format-10 is **not** supported, since it changes a default
-# that re-introduces a space into empty function bodies; this
-# can be turned off with a style setting, but that breaks
-# older format versions which don't recognize the setting.
+# Requires astyle >= 2.04 and clang-format-8 or later
 #
 # You can pass in directory names, in which case the files
 # in that directory (NOT below it) are processed.
@@ -20,9 +15,16 @@ LC_ALL=C
 LC_NUMERIC=C
 export LANG LC_ALL LC_NUMERIC
 
+BASEDIR=$(dirname $0)
+TOPDIR=$( cd $BASEDIR/.. && pwd -P )
+test -d "$BASEDIR" || { echo "! Could not determine base for $0" ; exit 1 ; }
+test -d "$TOPDIR" || { echo "! Cound not determine top-level source dir" ; exit 1 ; }
+test -f "$TOPDIR/.clang-format" || { echo "! No .clang-format support files in $TOPDIR" ; exit 1 ; }
+
 AS=$( which astyle )
 
-CF_VERSIONS="clang-format-7 clang-format-8 clang-format70 clang-format80 clang-format90 clang-format-9.0.1 clang-format"
+# Allow specifying CF_VERSIONS outside already
+CF_VERSIONS="$CF_VERSIONS clang-format13 clang-format-13 clang-format-13.0.1 clang-format12 clang-format-12 clang-format"
 for _cf in $CF_VERSIONS
 do
 	# Not an error if this particular clang-format isn't found
@@ -35,14 +37,30 @@ test -n "$CF" || { echo "! No clang-format ($CF_VERSIONS) found in PATH"; exit 1
 test -x "$AS" || { echo "! $AS is not executable."; exit 1 ; }
 test -x "$CF" || { echo "! $CF is not executable."; exit 1 ; }
 
-unmangle_clang_format=""
-if expr `"$CF" --version | tr -dc '[^.0-9]' | cut  -d . -f 1` '<' 10 > /dev/null ; then
-	:
-else
-	unmangle_clang_format=$( dirname $0 )/../.clang-format
-	echo "SpaceInEmptyBlock: false" >> "$unmangle_clang_format"
-fi
+### CLANG-FORMAT-WRANGLING
+#
+# Version 7 and earlier doesn't understand all the options we would like
+# Version 12 handles lambdas nicely, so use that.
+# Version 13 is also ok.
+# Version 14 behaves differently with short-functions-in-class,
+#   spreading functions out that 13 keeps on one line. To avoid
+#   ping-pong commits, forbid 14.
 
+format_version=`"$CF" --version | tr -dc '[^.0-9]' | cut  -d . -f 1`
+case "$format_version" in
+	12|13 )
+		:
+		;;
+	* )
+		echo "! Clang-format version '$format_version' unsupported, versions 12 or 13 are ok."
+		exit 1
+		;;
+esac
+
+
+### FILE PROCESSING
+#
+#
 set -e
 
 any_dirs=no
@@ -54,7 +72,7 @@ done
 style_some()
 {
 	if test -n "$*" ; then
-		$AS --options=$(dirname $0)/astylerc --quiet "$@"
+		$AS --options=$BASEDIR/astylerc --quiet "$@"
 		$CF -i -style=file "$@"
 	fi
 }
@@ -71,7 +89,3 @@ if test "x$any_dirs" = "xyes" ; then
 else
 	style_some "$@"
 fi
-
-if test -n "$unmangle_clang_format" ; then
-	sed -i.bak '/^SpaceInEmptyBlock/d' "$unmangle_clang_format"
-fi

ci/configvalidator.py

@@ -13,6 +13,7 @@ JSON-representable, anyway.
 
 Usage:
     configvalidator.py <schema> <file> ...
+    configvalidator.py -m <module>
     configvalidator.py -x
 
 Exits with value 0 on success, otherwise:
@@ -22,6 +23,8 @@ Exits with value 0 on success, otherwise:
     4 if files have invalid syntax
     5 if files fail to validate
 Use -x as only command-line argument to check the imports only.
+
+Use -m <module> as shorthand for standard paths in src/modules/<module>/
 """
 
 # The schemata originally lived outside the Calamares repository,
@@ -65,8 +68,13 @@ if len(sys.argv) < 3:
     print(usage)
     exit(ERR_USAGE)
 
-schema_file_name = sys.argv[1]
-config_file_names = sys.argv[2:]
+if len(sys.argv) == 3 and sys.argv[1] == "-m":
+    module = sys.argv[2]
+    schema_file_name = f"src/modules/{module}/{module}.schema.yaml"
+    config_file_names = [ f"src/modules/{module}/{module}.conf" ]
+else:
+    schema_file_name = sys.argv[1]
+    config_file_names = sys.argv[2:]
 
 if not exists(schema_file_name):
     print(usage)

ci/deps-debian11.sh

@@ -0,0 +1,45 @@
+#! /bin/sh
+#
+# Install dependencies for the nightly-debian (11) build
+#
+apt-get update
+apt-get -y install git-core jq curl ninja
+apt-get -y install \
+	build-essential \
+	cmake \
+	extra-cmake-modules \
+	gettext \
+	libatasmart-dev \
+	libappstreamqt-dev \
+	libboost-python-dev \
+	libicu-dev \
+	libparted-dev \
+	libpolkit-qt5-1-dev \
+	libqt5svg5-dev \
+	libqt5webkit5-dev \
+	libyaml-cpp-dev \
+	ninja-build \
+	os-prober \
+	pkg-config \
+	python3-dev \
+	qtbase5-dev \
+	qtdeclarative5-dev \
+	qttools5-dev \
+	qttools5-dev-tools
+# Same name as on KDE neon, different version
+apt-get -y install libkpmcore-dev
+# Additional dependencies (KF5, +)
+apt-get -y install \
+	libkf5config-dev \
+	libkf5coreaddons-dev \
+	libkf5i18n-dev \
+	libkf5iconthemes-dev \
+	libkf5parts-dev \
+	libkf5service-dev \
+	libkf5solid-dev \
+	libkf5crash-dev \
+	libkf5package-dev \
+	libkf5plasma-dev \
+	libpwquality-dev \
+	libqt5webenginewidgets5 \
+	qtwebengine5-dev

ci/deps-fedora-qt6.sh

@@ -0,0 +1,18 @@
+#! /bin/sh
+#
+# Install dependencies for the nightly-fedora-qt6 build
+#
+
+# Add the KF6 repo
+dnf install -y 'dnf-command(copr)'
+dnf copr enable -y @kdesig/kde-nightly-qt6
+
+yum install -y bison flex git make cmake gcc-c++ ninja-build
+yum install -y yaml-cpp-devel libpwquality-devel parted-devel python-devel gettext gettext-devel
+yum install -y libicu-devel libatasmart-devel
+# Qt6/KF6 dependencies
+yum install -y qt6-qtbase-devel qt6-linguist qt6-qtbase-private-devel qt6-qtdeclarative-devel qt6-qtsvg-devel qt6-qttools-devel
+yum install -y kf6-kcoreaddons-devel kf6-kdbusaddons-devel kf6-kcrash-devel
+yum install -y polkit-qt6-1-devel appstream-qt-devel
+# Runtime dependencies for QML modules
+yum install -y kf6-kirigami2-devel qt6-qt5compat-devel

ci/deps-neon.sh

@@ -0,0 +1,35 @@
+#! /bin/sh
+#
+# Install dependencies for the nightly-neon build
+#
+apt-get update
+apt-get -y install git-core jq ninja
+apt-get -y install \
+	build-essential \
+	cmake \
+	extra-cmake-modules \
+	gettext \
+	kio-dev \
+	libatasmart-dev \
+	libboost-python-dev \
+	libkf5config-dev \
+	libkf5coreaddons-dev \
+	libkf5i18n-dev \
+	libkf5iconthemes-dev \
+	libkf5parts-dev \
+	libkf5service-dev \
+	libkf5solid-dev \
+	libkpmcore-dev \
+	libparted-dev \
+	libpolkit-qt5-1-dev \
+	libqt5svg5-dev \
+	libqt5webkit5-dev \
+	libyaml-cpp-dev \
+	ninja-build \
+	os-prober \
+	pkg-config \
+	python3-dev \
+	qtbase5-dev \
+	qtdeclarative5-dev \
+	qttools5-dev \
+	qttools5-dev-tools

ci/deps-opensuse-qt6.sh

@@ -0,0 +1,20 @@
+#! /bin/sh
+# 
+# Install dependencies for the nightly-opensuse-qt6 build
+#
+# Add a Qt6/KF6 repo
+zypper --non-interactive addrepo -G https://download.opensuse.org/repositories/home:krop:kf6/openSUSE_Tumbleweed/home:krop:kf6.repo
+zypper --non-interactive addrepo -G https://download.opensuse.org/repositories/home:/krop:/Qt6:/Release/openSUSE_Tumbleweed/home:krop:Qt6:Release.repo
+
+zypper --non-interactive refresh
+zypper --non-interactive up
+zypper --non-interactive in git-core jq curl ninja
+# From deploycala.py
+zypper --non-interactive in bison flex git make cmake gcc-c++
+zypper --non-interactive in yaml-cpp-devel libpwquality-devel parted-devel python-devel libboost_headers-devel libboost_python3-devel
+zypper --non-interactive in libicu-devel libatasmart-devel
+# Qt6/KF6 dependencies
+zypper --non-interactive in qt6-concurrent-devel qt6-gui-devel qt6-linguist-devel qt6-network-devel qt6-svg-devel qt6-declarative-devel
+zypper --non-interactive in kf6-kcoreaddons-devel kf6-kdbusaddons-devel kf6-kcrash-devel
+zypper --non-interactive in kf6-kparts-devel # Also installs KF5 things
+zypper --non-interactive in libpolkit-qt6-1-devel

ci/deps-opensuse.sh

@@ -0,0 +1,42 @@
+#! /bin/sh
+#
+# Install dependencies for the nightly-opensuse build
+#
+zypper --non-interactive up
+zypper --non-interactive in git-core jq curl ninja
+# From deploycala.py
+zypper --non-interactive in \
+	"bison" \
+	"flex" \
+	"git" \
+	"make" \
+	"cmake" \
+	"gcc-c++"
+zypper --non-interactive in \
+	"libqt5-qtbase-devel" \
+	"libqt5-linguist-devel" \
+	"libqt5-qtsvg-devel" \
+	"libqt5-qtdeclarative-devel" \
+	"libqt5-qtwebengine-devel" \
+	"yaml-cpp-devel" \
+	"libpolkit-qt5-1-devel" \
+	"libpwquality-devel" \
+	"parted-devel" \
+	"python-devel" \
+	"libboost_headers-devel" \
+	"libboost_python3-devel"
+zypper --non-interactive in \
+	"extra-cmake-modules" \
+	"kdbusaddons-devel" \
+	"kservice-devel" \
+	"kpackage-devel" \
+	"kparts-devel" \
+	"kcrash-devel" \
+	"kpmcore-devel" \
+	"plasma5-workspace-devel" \
+	"plasma-framework-devel"
+# Additional dependencies
+zypper --non-interactive in \
+	libicu-devel \
+	libAppStreamQt-devel \
+	libatasmart-devel

ci/libcalamares/__init__.py

@@ -0,0 +1,9 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Stubs for part of the Python API from libcalamares
+# (although the **actual** API is presented through
+# Boost::Python, not as a bare C-extension) so that
+# pylint doesn't complain about libcalamares internals.
+
+VERSION_SHORT="1.0"

ci/libcalamares/globalstorage.py

@@ -0,0 +1,24 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Stubs for part of the Python API from libcalamares
+# (although the **actual** API is presented through
+# Boost::Python, not as a bare C-extension) so that
+# pylint doesn't complain about libcalamares internals.
+
+def count(): return 1
+
+def keys(): return []
+
+def contains(_): return True
+
+def value(key):
+    if key in ("branding",):
+        return dict()
+    if key in ("partitions",):
+        return list()
+    return ""
+
+def insert(key, value): pass
+
+def remove(_): pass

ci/libcalamares/job.py

@@ -0,0 +1,15 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Stubs for part of the Python API from libcalamares
+# (although the **actual** API is presented through
+# Boost::Python, not as a bare C-extension) so that
+# pylint doesn't complain about libcalamares internals.
+
+configuration = dict()
+
+def setprogress(_): pass
+
+def pretty_name(): return ""
+
+def working_path(): return ""

ci/libcalamares/utils.py

@@ -0,0 +1,27 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Stubs for part of the Python API from libcalamares
+# (although the **actual** API is presented through
+# Boost::Python, not as a bare C-extension) so that
+# pylint doesn't complain about libcalamares internals.
+
+def debug(_): pass
+
+def warning(_): pass
+
+def error(_): pass
+
+def gettext_path(): pass
+
+def gettext_languages(): pass
+
+def target_env_call(_): return 0
+
+def check_target_env_call(_): pass
+
+def target_env_process_output(cmd, *args): return 0
+
+def host_env_process_output(cmd, *args): return 0
+
+def mount(device, mountpoint, fstype, options): return 0

ci/travis-config.sh

@@ -1,16 +0,0 @@
-# Build configuration on Travis.
-#
-#   SPDX-FileCopyrightText: 2018 Adriaan de Groot <groot@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-# Defines a CMAKE_ARGS variable for use with cmake
-#
-# This file is sourced by travis.sh, and exports the variables
-# to the environment.
-CMAKE_ARGS="\
-  -DCMAKE_BUILD_TYPE=Release \
-  -DWEBVIEW_FORCE_WEBKIT=1 \
-  -DKDE_INSTALL_USE_QT_SYS_PATHS=ON \
-  -DWITH_PYTHONQT=OFF"
-
-export CMAKE_ARGS

ci/travis-continuous.sh

@@ -1,58 +0,0 @@
-#! /bin/sh
-#
-#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-# Travis CI script for use on every-commit:
-#  - build and install Calamares
-#
-test -n "$BUILDDIR" || { echo "! \$BUILDDIR not set" ; exit 1 ; }
-test -n "$SRCDIR" || { echo "! \$SRCDIR not set" ; exit 1 ; }
-
-test -d $BUILDDIR || { echo "! $BUILDDIR not a directory" ; exit 1 ; }
-test -d $SRCDIR || { echo "! $SRCDIR not a directory" ; exit 1 ; }
-test -f $SRCDIR/CMakeLists.txt || { echo "! Missing $SRCDIR/CMakeLists.txt" ; exit 1 ; }
-
-cd $BUILDDIR || exit 1
-
-section() {
-echo "###"
-echo "### $1"
-echo "###"
-pwd -P
-df -h
-}
-
-section "cmake $CMAKE_ARGS $SRCDIR"
-cmake $CMAKE_ARGS $SRCDIR || { echo "! CMake failed" ; exit 1 ; }
-
-section "make"
-make -j2 VERBOSE=1 || { echo "! Make recheck" ; pwd -P ; df -h ; make -j1 VERBOSE=1 ; echo "! Make failed" ; exit 1 ; }
-
-section "make install"
-
-install_debugging() {
-	ls -la $( find "$1" -type f -name '*.so' )
-}
-
-echo "# Build results"
-install_debugging "$BUILDDIR"
-
-echo "# Install"
-DESTDIR=/build/INSTALL_ROOT
-mkdir -p "$DESTDIR"
-
-if make install VERBOSE=1 DESTDIR="$DESTDIR" ;
-then
-	echo "# .. install OK"
-	result=true
-else
-	echo "# .. install failed"
-	result=false
-fi
-
-
-section "Install results"
-install_debugging "$DESTDIR"
-
-$result || { echo "! Install failed" ; exit 1 ; } # Result of make install, above

ci/travis-coverity.sh

@@ -1,37 +0,0 @@
-#! /bin/sh
-#
-#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-# Travis CI script for weekly (cron) use:
-#  - use the coverity tool to build and and upload results
-#
-test -n "$COVERITY_SCAN_TOKEN" || { echo "! Missing Coverity token" ; exit 1 ; }
-test -n "$BUILDDIR" || { echo "! \$BUILDDIR not set" ; exit 1 ; }
-test -n "$SRCDIR" || { echo "! \$SRCDIR not set" ; exit 1 ; }
-
-test -d $BUILDDIR || { echo "! $BUILDDIR not a directory" ; exit 1 ; }
-test -d $SRCDIR || { echo "! $SRCDIR not a directory" ; exit 1 ; }
-test -f $SRCDIR/CMakeLists.txt || { echo "! Missing $SRCDIR/CMakeLists.txt" ; exit 1 ; }
-
-cd $BUILDDIR || exit 1
-
-curl -k -o coverity_tool.tar.gz \
-  -d "token=$COVERITY_SCAN_TOKEN&project=calamares%2Fcalamares" \
-  https://scan.coverity.com/download/cxx/linux64 || exit 1
-mkdir "$BUILDDIR/coveritytool"
-tar xvf coverity_tool.tar.gz -C "$BUILDDIR/coveritytool" --strip-components 2
-export PATH="$BUILDDIR/coveritytool/bin:$PATH"
-
-echo "# cmake -DCMAKE_BUILD_TYPE=Debug $CMAKE_ARGS $SRCDIR"
-cmake -DCMAKE_BUILD_TYPE=Debug $CMAKE_ARGS $SRCDIR || exit 1
-cov-build --dir cov-int make -j2
-
-tar caf calamares-ci.tar.xz cov-int
-
-curl -k --form token=$COVERITY_SCAN_TOKEN \
-  --form email=groot@kde.org \
-  --form file=@calamares-ci.tar.xz \
-  --form version="calamares-`date -u +%Y%m%d`" \
-  --form description="calamares on `date -u`" \
-  https://scan.coverity.com/builds?project=calamares%2Fcalamares

ci/travis.sh

@@ -1,24 +0,0 @@
-#! /bin/sh
-#
-#   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
-#   SPDX-License-Identifier: BSD-2-Clause
-#
-# Travis build driver script:
-#  - the regular CI runs, triggered by commits,  run a script that builds
-#    and installs calamares, and then runs the tests.
-#  - the cronjob CI runs, triggered weekly, run a script that uses the
-#    coverity tools to submit a build. This is slightly more resource-
-#    intensive than the coverity add-on, but works on master.
-#
-D=`dirname "$0"`
-test -d "$D" || { echo "! No directory $D" ; exit 1 ; }
-test -x "$D/travis-continuous.sh" || { echo "! Missing -continuous" ; exit 1 ; }
-test -x "$D/travis-coverity.sh" || { echo "! Missing -coverity" ; exit 1 ; }
-
-test -f "$D/travis-config.sh" && . "$D/travis-config.sh"
-
-if test "$TRAVIS_EVENT_TYPE" = "cron" ; then
-  exec "$D/travis-coverity.sh"
-else
-  exec "$D/travis-continuous.sh"
-fi

ci/txcheck.sh

@@ -120,7 +120,7 @@ tx_sum()
 	WORKTREE_NAME="$1"
 	WORKTREE_TAG="$2"
 
-	git worktree add $WORKTREE_NAME $WORKTREE_TAG > /dev/null 2>&1 || { echo "! Could not create worktree." ; exit 1 ; }
+	git worktree add -d $WORKTREE_NAME $WORKTREE_TAG > /dev/null 2>&1 || { echo "! Could not create worktree." ; exit 1 ; }
 	( cd $WORKTREE_NAME && sh "$CURDIR"/ci/txpush.sh --no-tx ) > /dev/null 2>&1 || { echo "! Could not re-create translations." ; exit 1 ; }
 
 	# Remove linenumbers from .ts (XML) and .pot

ci/txpull.sh

@@ -55,7 +55,7 @@ done
 # .tx/config file to locate files, and overwrites them in the
 # filesystem with new (merged) translations.
 export QT_SELECT=5
-tx pull --force --source --all
+transifex-client pull --force --all || exit 1
 
 
 ### CLEANUP TRANSLATIONS
@@ -69,9 +69,6 @@ drop_language() {
 	mv calamares.desktop.new calamares.desktop
 }
 
-drop_language es_ES
-drop_language pl_PL
-
 # Also fix the .desktop file, which has some fields removed by Transifex.
 #
 { cat calamares.desktop.in ; grep "\\[[a-zA-Z_@]*]=" calamares.desktop ; } > calamares.desktop.new
@@ -108,6 +105,21 @@ awk '
 		skip=0; print $0;
 	}}' < calamares.desktop > calamares.desktop.new
 mv calamares.desktop.new calamares.desktop
+# Now group translated key-names (Name, Icon, Description, ..) by sorted
+# language key rather than random-ish language-key order (which shuffles
+# entries around).
+#
+# First, the non-translated lines
+grep -v '\[.*\]=' calamares.desktop  > calamares.desktop.new
+# The translated lines:
+# - replace (the first) [] by | so we have a consistent field separator
+# - sort based on field 2, then 1 (language code, then reversed key-name)
+# - replace the first | by [, the first (remaining) | by ]
+# Effectively this puts the fields in this order: Name, Icon, Generic Name,
+# Comment -- within each language key. This keeps churn down since the
+# language codes and key-names are constant.
+grep '\[.*\]=' calamares.desktop | sed -e 's/\[/|/' -e 's/\]/|/' | sort -t '|' -k 2,2 -k 1,1r | sed -e 's/|/\[/' | sed -e 's/|/\]/' >> calamares.desktop.new
+mv calamares.desktop.new calamares.desktop
 git add --verbose calamares.desktop
 git commit "$AUTHOR" --message="i18n: [desktop] $BOILERPLATE" | true
 
@@ -116,6 +128,19 @@ git commit "$AUTHOR" --message="i18n: [desktop] $BOILERPLATE" | true
 # PO-Created line). This applies only to modules which use po-files.
 git diff --numstat src/modules | awk '($1==1 && $2==1){print $3}' | xargs git checkout --
 
+# sed either wants -i'' (GNU sed) or -i '' (BSD sed) to
+# replace in a file, with no backup extension. Define
+# a `reinplace` command to deal with the difference.
+if test FreeBSD = `uname` ; then
+	reinplace() { 
+		sed -i '' "$@"
+	}
+else
+	reinplace() { 
+		sed -i'' "$@"
+	}
+fi
+
 # Go through the Python modules; those with a lang/ subdir have their
 # own complete gettext-based setup.
 for MODULE_DIR in $(find src/modules -maxdepth 1 -mindepth 1 -type d) ; do
@@ -125,7 +150,7 @@ for MODULE_DIR in $(find src/modules -maxdepth 1 -mindepth 1 -type d) ; do
 		if [ -d ${MODULE_DIR}/lang ]; then
 			# Convert PO files to MO files
 			for POFILE in $(find ${MODULE_DIR} -name "*.po") ; do
-				sed -i'' '/^"Content-Type/s/CHARSET/UTF-8/' $POFILE
+				reinplace '/^"Content-Type/s/CHARSET/UTF-8/' $POFILE
 				# msgfmt -o ${POFILE%.po}.mo $POFILE
 			done
 			git add --verbose ${MODULE_DIR}/lang/*
@@ -135,7 +160,7 @@ for MODULE_DIR in $(find src/modules -maxdepth 1 -mindepth 1 -type d) ; do
 done
 
 for POFILE in $(find lang -name "python.po") ; do
-	sed -i'' '/^"Content-Type/s/CHARSET/UTF-8/' $POFILE
+	reinplace '/^"Content-Type/s/CHARSET/UTF-8/' $POFILE
 	# msgfmt -o ${POFILE%.po}.mo $POFILE
 done
 git add --verbose lang/python*

ci/txpush.sh

@@ -53,6 +53,10 @@ if test "x$1" = "x--no-tx" ; then
 	}
 else
 	# tx is the regular transifex command
+	tx() {
+		transifex-client "$@"
+	}
+
 	# txtag is used to tag in git to measure changes
 	txtag() {
 		git tag -f translation
@@ -82,6 +86,15 @@ do
 done
 # XMLLINT is optional
 
+if sed --version 2>&1 | grep -q GNU ; then
+	reinplace() {
+		sed -i'' "$@"
+	}
+else
+	reinplace() {
+		sed -i '' "$@"
+	}
+fi
 
 ### CREATE TRANSLATIONS
 #
@@ -108,8 +121,8 @@ if test -n "$XMLLINT" ; then
 	$XMLLINT --c14n11 "$TS_FILE" | { echo "<!DOCTYPE TS>" ; cat - ; } | $XMLLINT --format --encode utf-8 -o "$TS_FILE".new - && mv "$TS_FILE".new "$TS_FILE"
 fi
 
-tx push --source --no-interactive -r calamares.calamares
-tx push --source --no-interactive -r calamares.fdo
+tx push --source -r calamares.calamares || exit 1
+tx push --source -r calamares.fdo || exit 1
 
 
 ### PYTHON MODULES
@@ -124,17 +137,16 @@ tx push --source --no-interactive -r calamares.fdo
 PYGETTEXT="xgettext --keyword=_n:1,2 -L python"
 
 SHARED_PYTHON=""
-for MODULE_DIR in $(find src/modules -maxdepth 1 -mindepth 1 -type d) ; do
-	FILES=$(find "$MODULE_DIR" -name "*.py" -a -type f)
+for MODULE_DIR in $(find src/modules -maxdepth 1 -mindepth 1 -type d | sort) ; do
+	FILES=$(find "$MODULE_DIR" -name "*.py" -a -type f | sort)
 	if test -n "$FILES" ; then
 		MODULE_NAME=$(basename ${MODULE_DIR})
 		if [ -d ${MODULE_DIR}/lang ]; then
 			${PYGETTEXT} -p ${MODULE_DIR}/lang -d ${MODULE_NAME} -o ${MODULE_NAME}.pot ${MODULE_DIR}/*.py
 			POTFILE="${MODULE_DIR}/lang/${MODULE_NAME}.pot"
 			if [ -f "$POTFILE" ]; then
-				sed -i'' '/^"Content-Type/s/CHARSET/UTF-8/' "$POTFILE"
-				tx set -r calamares.${MODULE_NAME} --source -l en "$POTFILE"
-				tx push --source --no-interactive -r calamares.${MODULE_NAME}
+				reinplace '/^"Content-Type/s/CHARSET/UTF-8/' "$POTFILE"
+				tx push --source -r calamares.${MODULE_NAME}
 			fi
 		else
 			SHARED_PYTHON="$SHARED_PYTHON $FILES"
@@ -145,9 +157,8 @@ done
 if test -n "$SHARED_PYTHON" ; then
 	${PYGETTEXT} -p lang -d python -o python.pot $SHARED_PYTHON
 	POTFILE="lang/python.pot"
-	sed -i'' '/^"Content-Type/s/CHARSET/UTF-8/' "$POTFILE"
-	tx set -r calamares.python --source -l en "$POTFILE"
-	tx push --source --no-interactive -r calamares.python
+	reinplace '/^"Content-Type/s/CHARSET/UTF-8/' "$POTFILE"
+	tx push --source -r calamares.python
 fi
 
 txtag

ci/txstats.py

@@ -11,6 +11,7 @@
 # Run it with a -v command-line option to get extra output on
 # actual translation percentages.
 import sys
+import os
 import argparse
 
 class TXError(Exception):
@@ -52,7 +53,7 @@ class TransifexGetter(object):
                 parser = configparser.ConfigParser()
                 parser.read_file(f)
 
-                return parser.get("https://www.transifex.com", "password")
+                return parser.get("https://app.transifex.com", "password")
         except IOError as e:
             return None
 
@@ -96,10 +97,12 @@ class EditingOutputter(object):
             lines = f.readlines()
 
         mark = None
+        mark_text = None
         for l in lines:
             # Note that we didn't strip the lines, so need the \n here
             if l.startswith("# Total ") and l.endswith(" languages\n"):
                 mark = lines.index(l)
+                mark_text = l
                 break
         if mark is None:
             raise TXError("No CMakeLists.txt lines for TX stats found")
@@ -107,18 +110,17 @@ class EditingOutputter(object):
 
         nextmark = mark + 1
         for l in lines[mark+1:]:
-            if l.startswith("set( _tx_"):
-                nextmark += 1
-                continue
-            if l.startswith("    "):
-                nextmark += 1
-                continue
-            break
-        if nextmark > mark + 12 or nextmark > len(lines) - 4:
+            nextmark += 1
+            if l.startswith(mark_text):
+                break
+        if nextmark > mark + 100 or nextmark > len(lines) - 4:
             # Try to catch runaway nextmarks: we know there should
             # be four set-lines, which are unlikely to be 3 lines each;
             # similarly the CMakeLists.txt is supposed to end with
             # some boilerplate.
+            #
+            # However, gersemi will reformat to one-language-per-line,
+            # so we can get really long sections, that's why we use 100 as a limit.
             raise TXError("Could not find end of TX settings in CMakeLists.txt")
         self.post_lines = lines[nextmark:]
 
@@ -172,23 +174,19 @@ def get_tx_stats(languages, outputter, verbose):
 
     If @p verbose is True, prints out language stats as well.
     """
-    suppressed_languages = ( "es_ES", )  # In Transifex, but not used
     # Some languages go into the "incomplete" list by definition,
     # regardless of their completion status: this can have various reasons.
     #
-    # Note that Esperanto (eo) is special-cased in CMakeLists.txt
-    # during the build; recent Qt releases *do* support the language,
-    # and it's at-the-least ok.
+    # - (Esperanto wasn't supported until Qt 5.12.2)
+    # - Interlingue still is not supported by the minimum Qt version
     incomplete_languages = (
-        "eo",   # Not supported by QLocale < 5.12.1
         "ie",   # Not supported by Qt at least through 5.15.0
         )
 
     all_langs = []
-    outputter.print("# Total %d languages" % len(languages))
+    mark_text = "# Total %d languages" % len(languages)
+    outputter.print(mark_text)
     for lang_name in languages:
-        if lang_name in suppressed_languages:
-            continue
         stats = languages[lang_name]["translated"]["percentage"]
         # Make the by-definition-incomplete languages have a percentage
         # lower than zero; this way they end up sorted (in -v output)
@@ -204,6 +202,39 @@ def get_tx_stats(languages, outputter, verbose):
     output_langs(all_langs, outputter, "good", lambda s : 1.0 > s >= 0.75)
     output_langs(all_langs, outputter, "ok", lambda s : 0.75 > s >= 0.05)
     output_langs(all_langs, outputter, "incomplete", lambda s : 0.05 > s)
+    outputter.print(mark_text)
+
+    # Audit the languages that are in TX, mapped to git
+    for lang_name in languages:
+        if not os.path.exists("lang/calamares_{}.ts".format(lang_name)):
+            print("# !! Missing translation file for {}".format(lang_name))
+        if not os.path.isdir("lang/python/{}/LC_MESSAGES".format(lang_name)):
+            print("# !! Missing Python translation file for {}".format(lang_name))
+
+    # Audit the files that are in git, mapped to TX
+    special_cases = ("python.pot", "python", "CMakeLists.txt", "txload.cpp", "calamares_i18n.qrc.in")
+    for file_name in os.listdir("lang"):
+        if file_name in special_cases:
+            continue
+        elif file_name.startswith("calamares_") and file_name.endswith(".ts"):
+            key = file_name[10:-3]
+            if not key in languages and not key == "en":
+                print("# !! Translation file for {} not in TX".format(key))
+        elif file_name.startswith("tz_") and file_name.endswith(".ts"):
+            key = file_name[3:-3]
+            if not key in languages and not key == "en":
+                print("# !! Translation file for TZ {} not in TX".format(key))
+        elif file_name.startswith("kb_") and file_name.endswith(".ts"):
+            key = file_name[3:-3]
+            if not key in languages and not key == "en":
+                print("# !! Translation file for KB {} not in TX".format(key))
+        else:
+            print("# !! Weird translation file {} not in TX".format(file_name))
+
+    # Audit the python translation files that are in git, mapped to TX
+    for file_name in os.listdir("lang/python"):
+        if file_name not in languages:
+            print("# !! Translation file for Python {} not in TX".format(file_name))
 
     return 0
 

ci/umount.sh

@@ -0,0 +1,29 @@
+#! /bin/sh
+
+### LICENSE
+# === This file is part of Calamares - <https://calamares.io> ===
+#
+#   SPDX-FileCopyrightText: 2022 Adriaan de Groot <groot@kde.org>
+#   SPDX-License-Identifier: BSD-2-Clause
+#
+#   This file is Free Software: you can redistribute it and/or modify
+#   it under the terms of the 2-clause BSD License.
+#
+### END LICENSE
+
+#
+# This is an "unmount" script that tries to unmount whatever
+# filesystems Calamares might have left mounted (e.g. because of
+# a crash, or ^C'ing the installer, or ..).
+#
+
+# Swap may have become enabled on the disks just used; assume
+# we're in a live session where we don't want any.
+sudo swapoff -a
+# In Arch-based systems, there may be a gpg-agent started by
+# pacman during installation, which lives in the chroot. Kill
+# them all; again assume we're in a live session where it doesn't matter.
+sudo pkill gpg-agent
+# Unmount the filesystems in *reverse* order, since we need to ditch
+# e.g. /run/udev before /run before the root filesystem.
+sudo umount $( LC_ALL=C mount | awk '/calamares-root/{print $3}' | LC_ALL=C sort -r )

data/FreeBSD/Makefile

@@ -1,37 +0,0 @@
-# $FreeBSD$
-# 
-# SPDX-FileCopyrightText: 2020 Adriaan de Groot <adridg@FreeBSD.org>
-# SPDX-License-Identifier: BSD-2-Clause
-
-PORTNAME=	calamares
-DISTVERSION=	3.2.25
-CATEGORIES=	sysutils
-MASTER_SITES=	https://github.com/${PORTNAME}/${PORTNAME}/releases/download/v${DISTVERSION}/
-
-MAINTAINER=	adridg@FreeBSD.org
-COMMENT=	GUI System installer and OEM configurator
-
-LICENSE=	GPLv3
-LICENSE_FILE=	${WRKSRC}/LICENSE
-
-LIB_DEPENDS=	libyaml-cpp.so:devel/yaml-cpp \
-		libpwquality.so:security/libpwquality \
-		libboost_python${PYTHON_SUFFIX}.so:devel/boost-python-libs
-
-USES=		cmake compiler:c++17-lang gettext kde:5 pkgconfig \
-		python:3.3+ qt:5
-USE_QT=		concurrent core dbus declarative gui \
-		network quickcontrols2 svg widgets xml \
-		buildtools_build linguist_build qmake_build
-USE_KDE=	coreaddons dbusaddons parts service \
-		ecm_build
-USE_LDCONFIG=	yes
-
-CMAKE_OFF=	WITH_KF5Crash \
-		INSTALL_CONFIG \
-		INSTALL_COMPLETION \
-		INSTALL_POLKIT
-CMAKE_ON=	CMAKE_DISABLE_FIND_PACKAGE_KPMcore
-CMAKE_ARGS=	-DSKIP_MODULES="webview"
-
-.include <bsd.port.mk>

data/FreeBSD/distinfo

@@ -1,3 +0,0 @@
-TIMESTAMP = 1592339404
-SHA256 (calamares-3.2.25.tar.gz) = 797ce33db7d4e4c06bbccef95f6c4023f7628e91bd142896695565fed4ae8c4b
-SIZE (calamares-3.2.25.tar.gz) = 3580197

data/FreeBSD/pkg-descr

@@ -1,14 +0,0 @@
-Calamares is an installer framework. By design it is very customizable,
-in order to satisfy a wide variety of needs and use cases.
-
-Calamares aims to be easy, usable, beautiful, pragmatic, inclusive and
-distribution-agnostic.
-
-Got a Linux distribution but no system installer? Grab Calamares, mix
-and match any number of Calamares modules (or write your own in Python
-or C++), throw together some branding, package it up and you are ready
-to ship!
-
-(The above applies to FreeBSD as well)
-
-WWW: https://calamares.io/

data/FreeBSD/pkg-plist

@@ -1,224 +0,0 @@
-bin/calamares
-include/libcalamares/CalamaresConfig.h
-include/libcalamares/CppJob.h
-include/libcalamares/DllMacro.h
-include/libcalamares/GlobalStorage.h
-include/libcalamares/Job.h
-include/libcalamares/JobExample.h
-include/libcalamares/JobQueue.h
-include/libcalamares/ProcessJob.h
-include/libcalamares/PythonHelper.h
-include/libcalamares/PythonJob.h
-include/libcalamares/PythonJobApi.h
-include/libcalamares/Settings.h
-include/libcalamares/utils/BoostPython.h
-include/libcalamares/utils/CalamaresUtilsSystem.h
-include/libcalamares/utils/CommandList.h
-include/libcalamares/utils/Dirs.h
-include/libcalamares/utils/Entropy.h
-include/libcalamares/utils/Logger.h
-include/libcalamares/utils/NamedEnum.h
-include/libcalamares/utils/NamedSuffix.h
-include/libcalamares/utils/PluginFactory.h
-include/libcalamares/utils/RAII.h
-include/libcalamares/utils/Retranslator.h
-include/libcalamares/utils/String.h
-include/libcalamares/utils/Tests.h
-include/libcalamares/utils/UMask.h
-include/libcalamares/utils/Units.h
-include/libcalamares/utils/Variant.h
-include/libcalamares/utils/Yaml.h
-include/libcalamares/utils/moc-warnings.h
-lib/calamares/libcalamares.so
-lib/calamares/modules/bootloader/main.py
-lib/calamares/modules/bootloader/module.desc
-lib/calamares/modules/bootloader/test.yaml
-lib/calamares/modules/contextualprocess/libcalamares_job_contextualprocess.so
-lib/calamares/modules/contextualprocess/module.desc
-lib/calamares/modules/displaymanager/main.py
-lib/calamares/modules/displaymanager/module.desc
-lib/calamares/modules/dracut/main.py
-lib/calamares/modules/dracut/module.desc
-lib/calamares/modules/dracutlukscfg/libcalamares_job_dracutlukscfg.so
-lib/calamares/modules/dracutlukscfg/module.desc
-lib/calamares/modules/dummycpp/libcalamares_job_dummycpp.so
-lib/calamares/modules/dummycpp/module.desc
-lib/calamares/modules/dummyprocess/module.desc
-lib/calamares/modules/dummypython/main.py
-lib/calamares/modules/dummypython/module.desc
-lib/calamares/modules/finished/libcalamares_viewmodule_finished.so
-lib/calamares/modules/finished/module.desc
-lib/calamares/modules/fstab/main.py
-lib/calamares/modules/fstab/module.desc
-lib/calamares/modules/fstab/test.yaml
-lib/calamares/modules/grubcfg/main.py
-lib/calamares/modules/grubcfg/module.desc
-lib/calamares/modules/hostinfo/libcalamares_job_hostinfo.so
-lib/calamares/modules/hostinfo/module.desc
-lib/calamares/modules/hwclock/main.py
-lib/calamares/modules/hwclock/module.desc
-lib/calamares/modules/initcpio/libcalamares_job_initcpio.so
-lib/calamares/modules/initcpio/module.desc
-lib/calamares/modules/initcpiocfg/main.py
-lib/calamares/modules/initcpiocfg/module.desc
-lib/calamares/modules/initramfs/libcalamares_job_initramfs.so
-lib/calamares/modules/initramfs/module.desc
-lib/calamares/modules/initramfscfg/encrypt_hook
-lib/calamares/modules/initramfscfg/encrypt_hook_nokey
-lib/calamares/modules/initramfscfg/main.py
-lib/calamares/modules/initramfscfg/module.desc
-lib/calamares/modules/interactiveterminal/libcalamares_viewmodule_interactiveterminal.so
-lib/calamares/modules/interactiveterminal/module.desc
-lib/calamares/modules/keyboard/libcalamares_viewmodule_keyboard.so
-lib/calamares/modules/keyboard/module.desc
-lib/calamares/modules/keyboardq/libcalamares_viewmodule_keyboardq.so
-lib/calamares/modules/keyboardq/module.desc
-lib/calamares/modules/license/libcalamares_viewmodule_license.so
-lib/calamares/modules/license/module.desc
-lib/calamares/modules/locale/libcalamares_viewmodule_locale.so
-lib/calamares/modules/locale/module.desc
-lib/calamares/modules/localecfg/main.py
-lib/calamares/modules/localecfg/module.desc
-lib/calamares/modules/localeq/libcalamares_viewmodule_localeq.so
-lib/calamares/modules/localeq/module.desc
-lib/calamares/modules/luksbootkeyfile/libcalamares_job_luksbootkeyfile.so
-lib/calamares/modules/luksbootkeyfile/module.desc
-lib/calamares/modules/luksopenswaphookcfg/main.py
-lib/calamares/modules/luksopenswaphookcfg/module.desc
-lib/calamares/modules/machineid/libcalamares_job_machineid.so
-lib/calamares/modules/machineid/module.desc
-lib/calamares/modules/mount/main.py
-lib/calamares/modules/mount/module.desc
-lib/calamares/modules/mount/test.yaml
-lib/calamares/modules/netinstall/libcalamares_viewmodule_netinstall.so
-lib/calamares/modules/netinstall/module.desc
-lib/calamares/modules/networkcfg/main.py
-lib/calamares/modules/networkcfg/module.desc
-lib/calamares/modules/notesqml/libcalamares_viewmodule_notesqml.so
-lib/calamares/modules/notesqml/module.desc
-lib/calamares/modules/oemid/libcalamares_viewmodule_oemid.so
-lib/calamares/modules/oemid/module.desc
-lib/calamares/modules/openrcdmcryptcfg/main.py
-lib/calamares/modules/openrcdmcryptcfg/module.desc
-lib/calamares/modules/packagechooser/libcalamares_viewmodule_packagechooser.so
-lib/calamares/modules/packagechooser/module.desc
-lib/calamares/modules/packages/main.py
-lib/calamares/modules/packages/module.desc
-lib/calamares/modules/packages/test.yaml
-lib/calamares/modules/plymouthcfg/main.py
-lib/calamares/modules/plymouthcfg/module.desc
-lib/calamares/modules/preservefiles/libcalamares_job_preservefiles.so
-lib/calamares/modules/preservefiles/module.desc
-lib/calamares/modules/rawfs/main.py
-lib/calamares/modules/rawfs/module.desc
-lib/calamares/modules/removeuser/libcalamares_job_removeuser.so
-lib/calamares/modules/removeuser/module.desc
-lib/calamares/modules/services-openrc/main.py
-lib/calamares/modules/services-openrc/module.desc
-lib/calamares/modules/services-systemd/main.py
-lib/calamares/modules/services-systemd/module.desc
-lib/calamares/modules/shellprocess/libcalamares_job_shellprocess.so
-lib/calamares/modules/shellprocess/module.desc
-lib/calamares/modules/summary/libcalamares_viewmodule_summary.so
-lib/calamares/modules/summary/module.desc
-lib/calamares/modules/tracking/libcalamares_viewmodule_tracking.so
-lib/calamares/modules/tracking/module.desc
-lib/calamares/modules/umount/main.py
-lib/calamares/modules/umount/module.desc
-lib/calamares/modules/unpackfs/main.py
-lib/calamares/modules/unpackfs/module.desc
-lib/calamares/modules/unpackfs/runtests.sh
-lib/calamares/modules/users/libcalamares_viewmodule_users.so
-lib/calamares/modules/users/module.desc
-lib/calamares/modules/welcome/libcalamares_viewmodule_welcome.so
-lib/calamares/modules/welcome/module.desc
-lib/calamares/modules/welcomeq/libcalamares_viewmodule_welcomeq.so
-lib/calamares/modules/welcomeq/module.desc
-lib/cmake/Calamares/CMakeColors.cmake
-lib/cmake/Calamares/CalamaresAddBrandingSubdirectory.cmake
-lib/cmake/Calamares/CalamaresAddLibrary.cmake
-lib/cmake/Calamares/CalamaresAddModuleSubdirectory.cmake
-lib/cmake/Calamares/CalamaresAddPlugin.cmake
-lib/cmake/Calamares/CalamaresAddTest.cmake
-lib/cmake/Calamares/CalamaresAddTranslations.cmake
-lib/cmake/Calamares/CalamaresAutomoc.cmake
-lib/cmake/Calamares/CalamaresConfig.cmake
-lib/cmake/Calamares/CalamaresConfigVersion.cmake
-lib/cmake/Calamares/CalamaresLibraryDepends-%%CMAKE_BUILD_TYPE%%.cmake
-lib/cmake/Calamares/CalamaresLibraryDepends.cmake
-lib/cmake/Calamares/CalamaresUse.cmake
-lib/libcalamares.so
-lib/libcalamares.so.3.2.25
-lib/libcalamaresui.so
-lib/libcalamaresui.so.3.2.25
-man/man8/calamares.8.gz
-share/applications/calamares.desktop
-%%DATADIR%%/branding/default/banner.png
-%%DATADIR%%/branding/default/branding.desc
-%%DATADIR%%/branding/default/lang/calamares-default_ar.qm
-%%DATADIR%%/branding/default/lang/calamares-default_en.qm
-%%DATADIR%%/branding/default/lang/calamares-default_eo.qm
-%%DATADIR%%/branding/default/lang/calamares-default_fr.qm
-%%DATADIR%%/branding/default/lang/calamares-default_nl.qm
-%%DATADIR%%/branding/default/languages.png
-%%DATADIR%%/branding/default/show.qml
-%%DATADIR%%/branding/default/squid.png
-%%DATADIR%%/branding/default/stylesheet.qss
-%%DATADIR%%/qml/calamares/slideshow/BackButton.qml
-%%DATADIR%%/qml/calamares/slideshow/ForwardButton.qml
-%%DATADIR%%/qml/calamares/slideshow/NavButton.qml
-%%DATADIR%%/qml/calamares/slideshow/Presentation.qml
-%%DATADIR%%/qml/calamares/slideshow/Slide.qml
-%%DATADIR%%/qml/calamares/slideshow/SlideCounter.qml
-%%DATADIR%%/qml/calamares/slideshow/qmldir
-share/icons/hicolor/scalable/apps/calamares.svg
-share/locale/ar/LC_MESSAGES/calamares-python.mo
-share/locale/as/LC_MESSAGES/calamares-python.mo
-share/locale/ast/LC_MESSAGES/calamares-python.mo
-share/locale/be/LC_MESSAGES/calamares-python.mo
-share/locale/bg/LC_MESSAGES/calamares-python.mo
-share/locale/ca/LC_MESSAGES/calamares-python.mo
-share/locale/cs_CZ/LC_MESSAGES/calamares-python.mo
-share/locale/da/LC_MESSAGES/calamares-python.mo
-share/locale/de/LC_MESSAGES/calamares-python.mo
-share/locale/el/LC_MESSAGES/calamares-python.mo
-share/locale/en_GB/LC_MESSAGES/calamares-python.mo
-share/locale/eo/LC_MESSAGES/calamares-python.mo
-share/locale/es/LC_MESSAGES/calamares-python.mo
-share/locale/es_MX/LC_MESSAGES/calamares-python.mo
-share/locale/es_PR/LC_MESSAGES/calamares-python.mo
-share/locale/et/LC_MESSAGES/calamares-python.mo
-share/locale/eu/LC_MESSAGES/calamares-python.mo
-share/locale/fi_FI/LC_MESSAGES/calamares-python.mo
-share/locale/fr/LC_MESSAGES/calamares-python.mo
-share/locale/gl/LC_MESSAGES/calamares-python.mo
-share/locale/he/LC_MESSAGES/calamares-python.mo
-share/locale/hi/LC_MESSAGES/calamares-python.mo
-share/locale/hr/LC_MESSAGES/calamares-python.mo
-share/locale/hu/LC_MESSAGES/calamares-python.mo
-share/locale/id/LC_MESSAGES/calamares-python.mo
-share/locale/is/LC_MESSAGES/calamares-python.mo
-share/locale/it_IT/LC_MESSAGES/calamares-python.mo
-share/locale/ja/LC_MESSAGES/calamares-python.mo
-share/locale/ko/LC_MESSAGES/calamares-python.mo
-share/locale/lt/LC_MESSAGES/calamares-python.mo
-share/locale/ml/LC_MESSAGES/calamares-python.mo
-share/locale/mr/LC_MESSAGES/calamares-python.mo
-share/locale/nb/LC_MESSAGES/calamares-python.mo
-share/locale/nl/LC_MESSAGES/calamares-python.mo
-share/locale/pl/LC_MESSAGES/calamares-python.mo
-share/locale/pt_BR/LC_MESSAGES/calamares-python.mo
-share/locale/pt_PT/LC_MESSAGES/calamares-python.mo
-share/locale/ro/LC_MESSAGES/calamares-python.mo
-share/locale/ru/LC_MESSAGES/calamares-python.mo
-share/locale/sk/LC_MESSAGES/calamares-python.mo
-share/locale/sl/LC_MESSAGES/calamares-python.mo
-share/locale/sq/LC_MESSAGES/calamares-python.mo
-share/locale/sr/LC_MESSAGES/calamares-python.mo
-share/locale/sr@latin/LC_MESSAGES/calamares-python.mo
-share/locale/sv/LC_MESSAGES/calamares-python.mo
-share/locale/th/LC_MESSAGES/calamares-python.mo
-share/locale/tr_TR/LC_MESSAGES/calamares-python.mo
-share/locale/uk/LC_MESSAGES/calamares-python.mo
-share/locale/zh_CN/LC_MESSAGES/calamares-python.mo
-share/locale/zh_TW/LC_MESSAGES/calamares-python.mo

lang/CMakeLists.txt

@@ -4,17 +4,35 @@
 #   SPDX-License-Identifier: BSD-2-Clause
 #
 ###
+#
+# This CMakeList handles the following i18n / language targets:
+#
+# - creating a translation test-tool
+# - building the Python (gettext-based) translations
+# - compiling all the Qt translations into a C++ file calamares-i18n.cxx
+# - defines an OBJECT LIBRARY calamares-i18n for linking the compiled
+#   translations into an executable.
 
-include( CalamaresAddTranslations )
+include(CalamaresAddTranslations)
 
-find_package(Qt5 COMPONENTS Xml)
-if( Qt5Xml_FOUND )
+find_package(${qtname} COMPONENTS Xml)
+if(TARGET ${qtname}::Xml)
     add_executable(txload txload.cpp)
-    target_link_libraries(txload Qt5::Xml)
+    target_link_libraries(txload ${qtname}::Xml)
 endif()
 
-install_calamares_gettext_translations( python
+install_calamares_gettext_translations(python
     SOURCE_DIR ${CMAKE_SOURCE_DIR}/lang/python
     FILENAME python.mo
     RENAME calamares-python.mo
 )
+
+### TRANSLATIONS
+#
+#
+calamares_qrc_translations(calamares-i18n
+    OUTPUT_VARIABLE translation_outfile
+    PREFIXES calamares tz kb
+)
+
+add_library(calamares-i18n OBJECT ${translation_outfile})