Changes: mention the -alpha1 release

No # in IDs (see *netinstall* schema for explanation).

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

.github/workflows/nightly-debian.yml

@@ -1,4 +1,4 @@
-name: nightly-debian-10
+name: nightly-debian-11
 
 on:
   schedule:
@@ -18,11 +18,53 @@ jobs:
   build:
     runs-on: ubuntu-latest
     container:
-      image: docker://debian:10
+      image: docker://debian:11
       options: --tmpfs /build:rw --user 0:0
     steps:
       - name: "prepare env"
-        uses: calamares/actions/prepare-debian@v4
+        shell: bash
+        run: |
+          apt-get update
+          # Make sure we can send notices later
+          apt-get -y install git-core jq curl
+          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 \
+            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
       - name: "prepare source"
         uses: calamares/actions/generic-checkout@v4
       - name: "build"

.github/workflows/nightly-opensuse.yml

@@ -18,11 +18,54 @@ jobs:
   build:
     runs-on: ubuntu-latest
     container:
-      image: docker://opensuse/leap
+      image: docker://opensuse/tumbleweed
       options: --tmpfs /build:rw --user 0:0
     steps:
       - name: "prepare env"
-        uses: calamares/actions/prepare-opensuse@v4
+        shell: bash
+        run: |
+          zypper --non-interactive up
+          zypper --non-interactive in git-core jq curl
+          # From deploycala.py
+          zypper --non-interactive in \
+            "autoconf" \
+            "automake" \
+            "bison" \
+            "flex" \
+            "git" \
+            "libtool" \
+            "m4" \
+            "make" \
+            "cmake" \
+            "extra-cmake-modules" \
+            "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 \
+            "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
       - name: "prepare source"
         uses: calamares/actions/generic-checkout@v4
       - name: "build"

.github/workflows/push.yml

@@ -3,6 +3,7 @@ name: ci-push
 on:
   push:
     branches:
+      - calamares
       - 3.2.x-stable
   pull_request:
     types:
@@ -30,7 +31,7 @@ jobs:
       - name: "prepare env"
         uses: calamares/actions/prepare-neon@v4
       - name: "prepare source"
-        uses: calamares/actions/generic-checkout@v4
+        uses: calamares/actions/generic-checkout@330c45ae1eb6efad4ad75a6dd887c3c5d5fe1590
       - name: "build"
         id: build
         uses: calamares/actions/generic-build@v4

.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

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 Qt5::Core Qt5::Network)

3rdparty/kdsingleapplication/KDSingleApplicationConfig.cmake.in

@@ -0,0 +1,7 @@
+include(CMakeFindDependencyMacro)
+
+find_dependency(Qt5Widgets REQUIRED)
+find_dependency(Qt5Network REQUIRED)
+
+# Add the targets file
+include("${CMAKE_CURRENT_LIST_DIR}/KDSingleApplicationTargets.cmake")

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;
-};

CHANGES-3.3

@@ -0,0 +1,62 @@
+<!-- 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 - 2021-12).
+
+# 3.3.0 (unreleased) #
+
+This release contains contributions from (alphabetically by first name):
+ - 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.
+
+Pre-release versions:
+ - 3.3.0-alpha1 (2022-06-27)
+
+## 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)
+ - *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
+ - *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)
+

CMakeLists.txt

@@ -25,10 +25,13 @@
 #                     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
+#                     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)
 #                       - SCHEMA_TESTING (requires Python, see ci/configvalidator.py)
+#                       - KF5Crash (uses KCrash, rather than Calamares internal, for crash reporting)
 #   DEBUG_<foo>     : special developer flags for debugging
 #
 # Example usage:
@@ -38,37 +41,45 @@
 # One special target is "show-version", which can be built
 # to obtain the version number from here.
 
-# TODO:3.3: Require CMake 3.12
-cmake_minimum_required( VERSION 3.3 FATAL_ERROR )
-project( CALAMARES
-    VERSION 3.2.61
-    LANGUAGES C CXX
-)
+cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
-# Leave this as "Release mode", since 3.2 is in LTS / bugfix-only state,
-# and should always be releaseable.
-set( CALAMARES_VERSION_RC 0 )  # Set to 0 during release cycle, 1 during development
-if( CALAMARES_VERSION_RC EQUAL 1 AND CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR )
-    message( FATAL_ERROR "Do not build development versions in the source-directory." )
+set(CALAMARES_VERSION 3.3.0-alpha1)
+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()
 
 ### 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_CONFIG "Install configuration files" OFF)
+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)
 #
-# 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_KF5Crash "Enable crash reporting with KCrash." ON)
 
 # Possible debugging flags are:
 #  - DEBUG_TIMEZONES draws latitude and longitude lines on the timezone
@@ -79,7 +90,6 @@ option( BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON )
 #  - DEBUG_PARTITION_UNSAFE (see partition/CMakeLists.txt)
 #  - DEBUG_PARTITION_BAIL_OUT (see partition/CMakeLists.txt)
 
-
 ### USE_*
 #
 # By convention, when there are multiple modules that implement similar
@@ -103,15 +113,14 @@ option( BUILD_SCHEMA_TESTING "Enable schema-validation-tests" ON )
 #  - *services* picks one of the two service-configuration modules,
 #    for either systemd or openrc. This defaults to empty so that
 #    **both** modules are available.
-set( USE_services "" CACHE STRING "Select the services module to use" )
+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
 #
@@ -145,32 +154,34 @@ 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 )
-
+set(QT_VERSION 5.15.0)
+set(YAMLCPP_VERSION 0.5.1)
+set(ECM_VERSION 5.18)
+set(PYTHONLIBS_VERSION 3.6)
+set(BOOSTPYTHON_VERSION 1.72.0)
 
 ### 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"
@@ -178,40 +189,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          "-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_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            "-Og -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 "-O4 -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")
 
-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
@@ -223,68 +244,69 @@ 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" )
+    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()
 
+# API that was deprecated before Qt 5.15 causes a compile error
+add_compile_definitions(QT_DISABLE_DEPRECATED_BEFORE=0x050f00)
 
 ### 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(Qt5 ${QT_VERSION} CONFIG REQUIRED Concurrent Core Gui LinguistTools Network Svg Widgets)
+if(WITH_QML)
+    find_package(Qt5 ${QT_VERSION} CONFIG REQUIRED Quick QuickWidgets)
 endif()
 # Optional Qt parts
-find_package( Qt5DBus CONFIG )
+find_package(Qt5DBus CONFIG)
 
-find_package( YAMLCPP ${YAMLCPP_VERSION} REQUIRED )
-if( INSTALL_POLKIT )
-    find_package( PolkitQt5-1 REQUIRED )
+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(PolkitQt5-1)
 endif()
 set_package_properties(
-    PolkitQt5-1 PROPERTIES
+    PolkitQt5-1
+    PROPERTIES
     DESCRIPTION "Qt5 support for Polkit"
     URL "https://cgit.kde.org/polkit-qt-1.git"
     PURPOSE "PolkitQt5-1 helps with installing Polkit configuration"
@@ -295,115 +317,96 @@ set_package_properties(
 #   find_package(ECM ${ECM_VERSION} REQUIRED NO_MODULE),
 # no need to mess with the module path after.
 find_package(ECM ${ECM_VERSION} NO_MODULE)
-if( ECM_FOUND )
+if(ECM_FOUND)
     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(Qt5 COMPONENTS Test REQUIRED)
+        include(ECMAddTests)
     endif()
     include(KDEInstallDirs)
 endif()
 
-find_package( KF5 QUIET COMPONENTS CoreAddons Crash DBusAddons )
+find_package(KF5 QUIET COMPONENTS CoreAddons Crash)
 set_package_properties(
-    KF5::CoreAddons PROPERTIES
+    KF5::CoreAddons
+    PROPERTIES
     TYPE REQUIRED
     DESCRIPTION "Classes built on QtCore for About Data"
     URL "https://api.kde.org/frameworks/kcoreaddons/"
     PURPOSE "About Calamares"
 )
-if( NOT KF5Crash_FOUND )
-    if( WITH_KF5Crash )
-        message(WARNING "WITH_KF5Crash is set, but KF5::Crash is not available.")
+if(NOT KF5Crash_FOUND)
+    if(BUILD_KF5Crash)
+        message(WARNING "BUILD_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 )
+    set(BUILD_KF5Crash OFF)
 endif()
 
-# TODO:3.3: Use FindPython3 instead
-find_package( PythonInterp ${PYTHONLIBS_VERSION} )
+find_package(Python ${PYTHONLIBS_VERSION} COMPONENTS Interpreter Development)
 set_package_properties(
-    PythonInterp PROPERTIES
-    DESCRIPTION "Python 3 interpreter."
+    Python
+    PROPERTIES
+    DESCRIPTION "Python3 interpreter."
     URL "https://python.org"
-    PURPOSE "Python 3 interpreter for certain tests."
+    PURPOSE "Python3 interpreter for certain tests."
 )
 
-set( _schema_explanation "" )
-if ( PYTHONINTERP_FOUND )
-    if ( BUILD_SCHEMA_TESTING )
+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})
 
 ### Transifex Translation status
@@ -413,39 +416,39 @@ set(Calamares_WITH_QML ${WITH_QML})
 # for some obvious error. The actual work of compiling translations
 # is done in the lang/ directory.
 #
-if( Qt5_VERSION VERSION_GREATER 5.12.1 )
+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 )
+    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" )
+        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
 #
@@ -464,22 +467,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(
@@ -490,105 +493,84 @@ 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}" )
 
 # 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( ExtendedVersion )
-    extend_version( "${CALAMARES_VERSION}" OFF CALAMARES_VERSION_SHORT CALAMARES_VERSION )
+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(Qml ${WITH_QML} "QML UI support")
 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(Polkit ${INSTALL_POLKIT} "Install Polkit files")
+add_feature_info(KCrash ${BUILD_KF5Crash} "Crash dumps via KCrash")
 
 ### 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(
@@ -605,69 +587,48 @@ install(
         "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_CONFIG)
+    install(FILES settings.conf DESTINATION share/calamares)
 endif()
 
-if( INSTALL_POLKIT )
-    install(
-        FILES com.github.calamares.calamares.policy
-        DESTINATION "${POLKITQT-1_POLICY_FILES_INSTALL_DIR}"
-    )
+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
 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)
 
 ### 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:"
@@ -684,11 +645,11 @@ feature_summary(
 #
 # Note: most distro's will do distro-specific packaging rather than
 #       using CPack, and this duplicates information in the AppStream, too.
-# TODO:3.3 With newer CMake, move HOMEPAGE_URL to the project()call
 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_HOMEPAGE_URL "https://calamares.io")
+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/CalamaresAddModuleSubdirectory.cmake

@@ -121,7 +121,8 @@ function( _calamares_add_module_subdirectory_impl )
         # _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" )

CMakeModules/CalamaresAddTest.cmake

@@ -18,19 +18,17 @@
 #   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
@@ -40,15 +38,18 @@ function( calamares_add_test )
                 ${TEST_LIBRARIES}
                 Qt5::Core
                 Qt5::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} Calamares::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 Qt5::Gui)
         endif()
-        if( TEST_RESOURCES )
+        if(TEST_RESOURCES)
             calamares_autorcc( ${TEST_NAME} ${TEST_RESOURCES} )
         endif()
     endif()

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/KPMcoreHelper.cmake

@@ -10,7 +10,7 @@
 if ( NOT KPMcore_searched_for )
     set( KPMcore_searched_for TRUE )
 
-    find_package( KPMcore 3.3 )
+    find_package( KPMcore 21.12.0 )
     set_package_properties(
         KPMcore PROPERTIES
         URL "https://invent.kde.org/kde/kpmcore"
@@ -21,18 +21,6 @@ if ( NOT KPMcore_searched_for )
 
     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()
     else()
         set( KPMcore_API_DEFINITIONS WITHOUT_KPMcore )
     endif()

CONTRIBUTING.md

@@ -77,16 +77,15 @@ instructions are on the wiki.
 ### Dependencies
 
 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
+* Qt >= 5.15
 * yaml-cpp >= 0.5.1
-* Python >= 3.3 (required for some modules)
-* Boost.Python >= 1.55.0 (required for some modules)
+* Python >= 3.6 (required for some modules)
+* Boost.Python >= 1.67.0 (required for some modules)
 * KDE extra-cmake-modules >= 5.18 (recommended; required for some modules;
   required for some tests)
 * KDE Frameworks KCoreAddons (>= 5.58 recommended)
-* PythonQt (optional, deprecated)
 
 Individual modules may have their own requirements;
 these are listed in CMake output.

CalamaresConfig.cmake.in

@@ -87,5 +87,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@)

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!

calamares.desktop

@@ -3,14 +3,16 @@ Type=Application
 Version=1.0
 Name=Install System
 GenericName=System Installer
+Comment=Calamares — System Installer
 Keywords=calamares;system;installer;
 TryExec=calamares
 Exec=sh -c "pkexec calamares"
-Comment=Calamares — System Installer
+
+Categories=Qt;System;
 Icon=calamares
 Terminal=false
+SingleMainWindow=true
 StartupNotify=true
-Categories=Qt;System;
 X-AppStream-Ignore=true
 
 Name[ar]=تثبيت النظام 

ci/RELEASE.sh

@@ -127,7 +127,7 @@ fi
 ### Get version number for this release
 #
 #
-V=$( cd "$BUILDDIR" && make show-version | grep ^CALAMARES_VERSION | sed s/^[A-Z_]*=// )
+V=$( cd "$BUILDDIR" && cmake -P ../CMakeLists.txt | grep ^CALAMARES_VERSION | sed s/^[A-Z_]*=// )
 test -n "$V" || { echo "Could not obtain version in $BUILDDIR ." ; exit 1 ; }
 
 ### Create signed tag

ci/abicheck.sh

@@ -0,0 +1,73 @@
+#! /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 the very start of 3.3, when ABI
+# compatibility was not expected yet at **all**.
+BASE_VERSION=419be4df25bc6fcc1958cb6e44afc1b9e64fce71
+
+### 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/txstats.py

@@ -97,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")
@@ -108,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:]
 
@@ -185,7 +186,8 @@ def get_tx_stats(languages, outputter, verbose):
         )
 
     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:
         stats = languages[lang_name]["translated"]["percentage"]
         # Make the by-definition-incomplete languages have a percentage
@@ -202,6 +204,7 @@ 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:

lang/CMakeLists.txt

@@ -13,15 +13,15 @@
 # - 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 )
+if(Qt5Xml_FOUND)
     add_executable(txload txload.cpp)
     target_link_libraries(txload Qt5::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
@@ -30,25 +30,25 @@ install_calamares_gettext_translations( python
 ### TRANSLATIONS
 #
 #
-set( TS_FILES "" )
-set( calamares_i18n_qrc_content "" )
+set(TS_FILES "")
+set(calamares_i18n_qrc_content "")
 
 # calamares and qt language files
-foreach( lang ${CALAMARES_TRANSLATION_LANGUAGES} )
-    foreach( tlsource "calamares_${lang}" "tz_${lang}" "kb_${lang}" )
-        if( EXISTS "${CMAKE_SOURCE_DIR}/lang/${tlsource}.ts" )
-            string( APPEND calamares_i18n_qrc_content "<file>${tlsource}.qm</file>\n" )
-            list( APPEND TS_FILES "${CMAKE_SOURCE_DIR}/lang/${tlsource}.ts" )
+foreach(lang ${CALAMARES_TRANSLATION_LANGUAGES})
+    foreach(tlsource "calamares_${lang}" "tz_${lang}" "kb_${lang}")
+        if(EXISTS "${CMAKE_SOURCE_DIR}/lang/${tlsource}.ts")
+            string(APPEND calamares_i18n_qrc_content "<file>${tlsource}.qm</file>\n")
+            list(APPEND TS_FILES "${CMAKE_SOURCE_DIR}/lang/${tlsource}.ts")
         endif()
     endforeach()
 endforeach()
 
-set( trans_file calamares_i18n )
-set( trans_infile ${CMAKE_CURRENT_BINARY_DIR}/${trans_file}.qrc )
-set( trans_outfile ${CMAKE_CURRENT_BINARY_DIR}/calamares-i18n.cxx )
-set( CALAMARES_TRANSLATIONS_SOURCE ${trans_outfile} )
+set(trans_file calamares_i18n)
+set(trans_infile ${CMAKE_CURRENT_BINARY_DIR}/${trans_file}.qrc)
+set(trans_outfile ${CMAKE_CURRENT_BINARY_DIR}/calamares-i18n.cxx)
+set(CALAMARES_TRANSLATIONS_SOURCE ${trans_outfile})
 
-configure_file( ${CMAKE_SOURCE_DIR}/lang/calamares_i18n.qrc.in ${trans_infile} @ONLY )
+configure_file(${CMAKE_SOURCE_DIR}/lang/calamares_i18n.qrc.in ${trans_infile} @ONLY)
 
 qt5_add_translation(QM_FILES ${TS_FILES})
 

lang/calamares_en.ts

@@ -283,16 +283,16 @@
       <location filename="../src/libcalamares/modulesystem/RequirementsChecker.cpp" line="118"/>
       <source>Waiting for %n module(s).</source>
       <translation>
-        <numerusform>Waiting for %n module(s).</numerusform>
-        <numerusform>Waiting for %n module(s).</numerusform>
+        <numerusform>Waiting for %n module.</numerusform>
+        <numerusform>Waiting for %n modules.</numerusform>
       </translation>
     </message>
     <message numerus="yes">
       <location filename="../src/libcalamares/modulesystem/RequirementsChecker.cpp" line="119"/>
       <source>(%n second(s))</source>
       <translation>
-        <numerusform>(%n second(s))</numerusform>
-        <numerusform>(%n second(s))</numerusform>
+        <numerusform>(%n second)</numerusform>
+        <numerusform>(%n seconds)</numerusform>
       </translation>
     </message>
     <message>

src/CMakeLists.txt

@@ -3,26 +3,26 @@
 #   SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
 #   SPDX-License-Identifier: BSD-2-Clause
 #
-include( CalamaresAddBrandingSubdirectory )
-include( CalamaresAddLibrary )
-include( CalamaresAddModuleSubdirectory )
-include( CalamaresAddPlugin )
-include( CalamaresAddTest )
-include( CalamaresAddTranslations )
+include(CalamaresAddBrandingSubdirectory)
+include(CalamaresAddLibrary)
+include(CalamaresAddModuleSubdirectory)
+include(CalamaresAddPlugin)
+include(CalamaresAddTest)
+include(CalamaresAddTranslations)
 
 # library
-add_subdirectory( libcalamares )
+add_subdirectory(libcalamares)
 
-add_subdirectory( libcalamaresui )
+add_subdirectory(libcalamaresui)
 
 # all things qml
-add_subdirectory( qml/calamares )
+add_subdirectory(qml/calamares)
 
 # application
-add_subdirectory( calamares )
+add_subdirectory(calamares)
 
 # plugins
-add_subdirectory( modules )
+add_subdirectory(modules)
 
 # branding components
-add_subdirectory( branding )
+add_subdirectory(branding)

src/branding/README.md

@@ -204,3 +204,22 @@ Adding the subdirectory can be done as follows:
    to `.qm` files before being installed. The CMake macro's do this
    automatically. For manual packaging, use `lrelease` to compile
    the files.
+
+## Global Storage keys
+
+The following keys from the `branding.desc` file are copied into
+Global Storage under a *branding* parent key:
+    "productName",
+    "version",
+    "shortVersion",
+    "versionedName",
+    "shortVersionedName",
+    "shortProductName",
+    "bootloaderEntryName",
+    "productUrl",
+    "supportUrl",
+    "knownIssuesUrl",
+    "releaseNotesUrl",
+    "donateUrl"
+
+<!-- see Branding::s_stringEntryStrings and Branding::setGlobals() -->

src/branding/default/branding.desc

@@ -170,20 +170,20 @@ images:
 
 # Colors for text and background components.
 #
-#  - sidebarBackground is the background of the sidebar
-#  - sidebarText is the (foreground) text color
-#  - sidebarTextHighlight sets the background of the selected (current) step.
+#  - SidebarBackground is the background of the sidebar
+#  - SidebarText is the (foreground) text color
+#  - SidebarBackgroundCurrent sets the background of the current step.
 #    Optional, and defaults to the application palette.
-#  - sidebarSelect is the text color of the selected step.
+#  - SidebarTextCurrent is the text color of the current step.
 #
 # These colors can **also** be set through the stylesheet, if the
 # branding component also ships a stylesheet.qss. Then they are
 # the corresponding CSS attributes of #sidebarApp.
 style:
-   sidebarBackground:    "#292F34"
-   sidebarText:          "#FFFFFF"
-   sidebarTextSelect:    "#292F34"
-   sidebarTextHighlight: "#D35400"
+   SidebarBackground:        "#292F34"
+   SidebarText:              "#FFFFFF"
+   SidebarTextCurrent:       "#292F34"
+   SidebarBackgroundCurrent: "#D35400"
 
 ### SLIDESHOW
 #

src/calamares/CMakeLists.txt

@@ -4,29 +4,16 @@
 #   SPDX-License-Identifier: BSD-2-Clause
 #
 
-set( calamaresSources
+set(calamaresSources
     main.cpp
     CalamaresApplication.cpp
     CalamaresWindow.cpp
-
     DebugWindow.cpp
     VariantModel.cpp
-
     progresstree/ProgressTreeDelegate.cpp
     progresstree/ProgressTreeView.cpp
 )
 
-if( NOT WITH_KF5DBus )
-    set( kdsagSources
-        ${CMAKE_SOURCE_DIR}/3rdparty/kdsingleapplicationguard/kdsingleapplicationguard.cpp
-        ${CMAKE_SOURCE_DIR}/3rdparty/kdsingleapplicationguard/kdsharedmemorylocker.cpp
-        ${CMAKE_SOURCE_DIR}/3rdparty/kdsingleapplicationguard/kdtoolsglobal.cpp
-        ${CMAKE_SOURCE_DIR}/3rdparty/kdsingleapplicationguard/kdlockedsharedmemorypointer.cpp
-    )
-    mark_thirdparty_code( ${kdsagSources} )
-    list( APPEND calamaresSources ${kdsagSources} )
-endif()
-
 include_directories(
     ${CMAKE_SOURCE_DIR}/src/libcalamares
     ${CMAKE_SOURCE_DIR}/src/libcalamaresui
@@ -42,45 +29,26 @@ include_directories(
 # The calamares-i18n.cxx file -- full path in CALAMARES_TRANSLATIONS_SOURCE --
 # is created as a target in the lang/ directory. This is compiled to a
 # library (it's just the result of a QRC compile).
-add_executable( calamares_bin ${calamaresSources} calamares.qrc )
-target_include_directories( calamares_bin PRIVATE ${CMAKE_SOURCE_DIR} )
-set_target_properties(calamares_bin
-    PROPERTIES
-        ENABLE_EXPORTS TRUE
-        RUNTIME_OUTPUT_NAME calamares
-)
+add_executable(calamares_bin ${calamaresSources} calamares.qrc)
+target_include_directories(calamares_bin PRIVATE ${CMAKE_SOURCE_DIR})
+set_target_properties(calamares_bin PROPERTIES ENABLE_EXPORTS TRUE RUNTIME_OUTPUT_NAME calamares)
 calamares_automoc( calamares_bin )
 calamares_autouic( calamares_bin )
 calamares_autorcc( calamares_bin )
 
-if( kdsagSources )
-    set_source_files_properties( ${kdsagSources} PROPERTIES AUTOMOC OFF )
-endif()
-
-target_link_libraries( calamares_bin
-    PRIVATE
-        calamares
-        calamaresui
-        calamares-i18n
-        Qt5::Core
-        Qt5::Widgets
-        KF5::CoreAddons
+target_link_libraries(
+    calamares_bin
+    PRIVATE calamares calamaresui calamares-i18n kdsingleapplication Qt5::Core Qt5::Widgets KF5::CoreAddons
 )
-if( WITH_KF5Crash )
-    target_link_libraries( calamares_bin PRIVATE KF5::Crash )
-    target_compile_definitions( calamares_bin PRIVATE WITH_KF5Crash )
-endif()
-if( WITH_KF5DBus )
-    target_link_libraries( calamares_bin PRIVATE KF5::DBusAddons )
-    target_compile_definitions( calamares_bin PRIVATE WITH_KF5DBus )
+if(BUILD_KF5Crash)
+    target_link_libraries(calamares_bin PRIVATE KF5::Crash)
+    target_compile_definitions(calamares_bin PRIVATE BUILD_KF5Crash)
 endif()
 
-install( TARGETS calamares_bin
-    BUNDLE DESTINATION .
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
+install(TARGETS calamares_bin BUNDLE DESTINATION . RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-install( FILES ${CMAKE_SOURCE_DIR}/data/images/squid.svg
+install(
+    FILES ${CMAKE_SOURCE_DIR}/data/images/squid.svg
     RENAME calamares.svg
     DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/scalable/apps
 )
@@ -88,11 +56,11 @@ install( FILES ${CMAKE_SOURCE_DIR}/data/images/squid.svg
 ### TESTS
 #
 #
-if( BUILD_TESTING )
+if(BUILD_TESTING)
     # Don't install, these are just for enable_testing
-    add_executable( loadmodule testmain.cpp )
-    target_link_libraries( loadmodule PRIVATE Qt5::Core Qt5::Widgets calamares calamaresui )
+    add_executable(loadmodule testmain.cpp)
+    target_link_libraries(loadmodule PRIVATE Qt5::Core Qt5::Widgets calamares calamaresui)
 
-    add_executable( test_conf test_conf.cpp )
-    target_link_libraries( test_conf PUBLIC yamlcpp::yamlcpp Qt5::Core )
+    add_executable(test_conf test_conf.cpp)
+    target_link_libraries(test_conf PUBLIC yamlcpp::yamlcpp Qt5::Core)
 endif()

src/calamares/CalamaresApplication.h

@@ -18,7 +18,7 @@ class CalamaresWindow;
 namespace Calamares
 {
 class ModuleManager;
-}
+}  // namespace Calamares
 
 
 /**

src/calamares/DebugWindow.cpp

@@ -27,13 +27,6 @@
 #include "utils/Retranslator.h"
 #include "widgets/TranslationFix.h"
 
-#ifdef WITH_PYTHONQT
-#include "ViewManager.h"
-#include "viewpages/PythonQtViewStep.h"
-
-#include <gui/PythonQtScriptingConsole.h>
-#endif
-
 #include <QMessageBox>
 #include <QSplitter>
 #include <QStringListModel>
@@ -120,79 +113,10 @@ DebugWindow::DebugWindow()
 
     m_ui->moduleConfigView->setModel( m_module_model.get() );
 
-#ifdef WITH_PYTHONQT
-    QPushButton* pythonConsoleButton = new QPushButton;
-    pythonConsoleButton->setText( "Attach Python console" );
-    m_ui->modulesVerticalLayout->insertWidget( 1, pythonConsoleButton );
-    pythonConsoleButton->hide();
-
-    QObject::connect(
-        pythonConsoleButton,
-        &QPushButton::clicked,
-        this,
-        [ this, moduleConfigModel ]
-        {
-            QString moduleName = m_ui->modulesListView->currentIndex().data().toString();
-            Module* module = ModuleManager::instance()->moduleInstance( moduleName );
-            if ( module->interface() != Module::Interface::PythonQt || module->type() != Module::Type::View )
-                return;
-
-            for ( ViewStep* step : ViewManager::instance()->viewSteps() )
-            {
-                if ( step->moduleInstanceKey() == module->instanceKey() )
-                {
-                    PythonQtViewStep* pqvs = qobject_cast< PythonQtViewStep* >( step );
-                    if ( pqvs )
-                    {
-                        QWidget* consoleWindow = new QWidget;
-
-                        QWidget* console = pqvs->createScriptingConsole();
-                        console->setParent( consoleWindow );
-
-                        QVBoxLayout* layout = new QVBoxLayout;
-                        consoleWindow->setLayout( layout );
-                        layout->addWidget( console );
-
-                        QHBoxLayout* bottomLayout = new QHBoxLayout;
-                        layout->addLayout( bottomLayout );
-
-                        QLabel* bottomLabel = new QLabel( consoleWindow );
-                        bottomLayout->addWidget( bottomLabel );
-                        QString line = QString( "Module: <font color=\"#008000\"><code>%1</code></font><br/>"
-                                                "Python class: <font color=\"#008000\"><code>%2</code></font>" )
-                                           .arg( module->instanceKey() )
-                                           .arg( console->property( "classname" ).toString() );
-                        bottomLabel->setText( line );
-
-                        QPushButton* closeButton = new QPushButton( consoleWindow );
-                        closeButton->setText( "&Close" );
-                        QObject::connect(
-                            closeButton, &QPushButton::clicked, [ consoleWindow ] { consoleWindow->close(); } );
-                        bottomLayout->addWidget( closeButton );
-                        bottomLabel->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred );
-
-                        consoleWindow->setParent( this );
-                        consoleWindow->setWindowFlags( Qt::Window );
-                        consoleWindow->setWindowTitle( "Calamares Python console" );
-                        consoleWindow->setAttribute( Qt::WA_DeleteOnClose, true );
-                        consoleWindow->showNormal();
-                        break;
-                    }
-                }
-            }
-        } );
-
-#endif
-
     connect( m_ui->modulesListView->selectionModel(),
              &QItemSelectionModel::selectionChanged,
              this,
-             [ this
-#ifdef WITH_PYTHONQT
-               ,
-               pythonConsoleButton
-#endif
-    ]
+             [ this ]
              {
                  QString moduleName = m_ui->modulesListView->currentIndex().data().toString();
                  Module* module
@@ -204,10 +128,6 @@ DebugWindow::DebugWindow()
                      m_ui->moduleConfigView->expandAll();
                      m_ui->moduleTypeLabel->setText( module->typeString() );
                      m_ui->moduleInterfaceLabel->setText( module->interfaceString() );
-#ifdef WITH_PYTHONQT
-                     pythonConsoleButton->setVisible( module->interface() == Module::Interface::PythonQt
-                                                      && module->type() == Module::Type::View );
-#endif
                  }
              } );
 

src/calamares/DebugWindow.h

@@ -26,7 +26,7 @@ namespace Calamares
 namespace Ui
 {
 class DebugWindow;
-}
+}  // namespace Ui
 
 class DebugWindow : public QWidget
 {

src/calamares/DebugWindow.ui

@@ -5,7 +5,7 @@ SPDX-FileCopyrightText: 2015 Teo Mrnjavac <teo@kde.org>
 SPDX-License-Identifier: GPL-3.0-or-later
  </author>
  <class>Calamares::DebugWindow</class>
- <widget class="QWidget" name="Calamares::DebugWindow">
+ <widget class="QWidget" name="DebugWindow">
   <property name="geometry">
    <rect>
     <x>0</x>

src/calamares/calamares-sidebar.qml

@@ -46,12 +46,12 @@ Rectangle {
                 Layout.fillWidth: true;
                 height: 35;
                 radius: 6;
-                color: Branding.styleString( index == ViewManager.currentStepIndex ? Branding.SidebarBackgroundSelected : Branding.SidebarBackground );
+                color: Branding.styleString( index == ViewManager.currentStepIndex ? Branding.SidebarBackgroundCurrent : Branding.SidebarBackground );
 
                 Text {
                     anchors.verticalCenter: parent.verticalCenter;
                     anchors.horizontalCenter: parent.horizontalCenter;
-                    color: Branding.styleString( index == ViewManager.currentStepIndex ? Branding.SidebarTextSelected : Branding.SidebarText );
+                    color: Branding.styleString( index == ViewManager.currentStepIndex ? Branding.SidebarTextCurrent : Branding.SidebarText );
                     text: display;
                 }
             }
@@ -66,7 +66,7 @@ Rectangle {
             Layout.fillWidth: true;
             height: 35
             Layout.alignment: Qt.AlignHCenter | Qt.AlignBottom
-            color: Branding.styleString( Branding.SidebarTextHighlight );
+            color: Branding.styleString( Branding.SidebarBackground );
             visible: true;
 
             Rectangle {
@@ -74,7 +74,7 @@ Rectangle {
                 height: 35
                 width: parent.width / 2;
                 anchors.left: parent.left
-                color: Branding.styleString( Branding.SidebarTextHighlight );
+                color: Branding.styleString( Branding.SidebarBackgroundCurrent );
                 visible: true;
 
                 MouseArea {
@@ -87,7 +87,7 @@ Rectangle {
                         anchors.horizontalCenter: parent.horizontalCenter;
                         x: parent.x + 4;
                         text: qsTr("About")
-                        color: Branding.styleString( Branding.SidebarTextSelect );
+                        color: Branding.styleString( Branding.SidebarTextCurrent );
                         font.pointSize : 9
                     }
 
@@ -100,7 +100,7 @@ Rectangle {
                 height: 35
                 width: parent.width / 2;
                 anchors.right: parent.right
-                color: Branding.styleString( Branding.SidebarTextHighlight );
+                color: Branding.styleString( Branding.SidebarBackgroundCurrent );
                 visible: debug.enabled
 
                 MouseArea {
@@ -113,7 +113,7 @@ Rectangle {
                         anchors.horizontalCenter: parent.horizontalCenter;
                         x: parent.x + 4;
                         text: qsTr("Debug")
-                        color: Branding.styleString( Branding.SidebarTextSelect );
+                        color: Branding.styleString( Branding.SidebarTextCurrent );
                         font.pointSize : 9
                     }
 

src/calamares/main.cpp

@@ -16,15 +16,11 @@
 #include "utils/Logger.h"
 #include "utils/Retranslator.h"
 
-#ifndef WITH_KF5DBus
-#include "3rdparty/kdsingleapplicationguard/kdsingleapplicationguard.h"
-#endif
+// From 3rdparty/
+#include "kdsingleapplication.h"
 
 #include <KCoreAddons/KAboutData>
-#ifdef WITH_KF5DBus
-#include <KDBusAddons/KDBusService>
-#endif
-#ifdef WITH_KF5Crash
+#ifdef BUILD_KF5Crash
 #include <KCrash/KCrash>
 #endif
 
@@ -32,6 +28,8 @@
 #include <QDebug>
 #include <QDir>
 
+#include <memory>
+
 /** @brief Gets debug-level from -D command-line-option
  *
  * If unset, use LOGERROR (corresponding to -D1), although
@@ -123,37 +121,24 @@ main( int argc, char* argv[] )
     KAboutData::setApplicationData( aboutData );
     a.setApplicationDisplayName( QString() );  // To avoid putting an extra "Calamares/" into the log-file
 
-#ifdef WITH_KF5Crash
+#ifdef BUILD_KF5Crash
     KCrash::initialize();
     // KCrash::setCrashHandler();
     KCrash::setDrKonqiEnabled( true );
     KCrash::setFlags( KCrash::SaferDialog | KCrash::AlwaysDirectly );
-    // TODO: umount anything in /tmp/calamares-... as an emergency save function
 #endif
 
-    bool is_debug = handle_args( a );
-
-#ifdef WITH_KF5DBus
-    KDBusService service( is_debug ? KDBusService::Multiple : KDBusService::Unique );
-#else
-    KDSingleApplicationGuard guard( is_debug ? KDSingleApplicationGuard::NoPolicy
-                                             : KDSingleApplicationGuard::AutoKillOtherInstances );
-    if ( !is_debug && !guard.isPrimaryInstance() )
+    std::unique_ptr< KDSingleApplication > possiblyUnique;
+    const bool is_debug = handle_args( a );
+    if ( !is_debug )
     {
-        // Here we have not yet set-up the logger system, so qDebug() is ok
-        auto instancelist = guard.instances();
-        qDebug() << "Calamares is already running, shutting down.";
-        if ( instancelist.count() > 0 )
+        possiblyUnique = std::make_unique< KDSingleApplication >();
+        if ( !possiblyUnique->isPrimaryInstance() )
         {
-            qDebug() << "Other running Calamares instances:";
+            qCritical() << "Calamares is already running.";
+            return 87;  // EUSERS on Linux
         }
-        for ( const auto& i : instancelist )
-        {
-            qDebug() << "  " << i.isValid() << i.pid() << i.arguments();
-        }
-        return 69;  // EX_UNAVAILABLE on FreeBSD
     }
-#endif
 
     Calamares::Settings::init( is_debug );
     if ( !Calamares::Settings::instance() || !Calamares::Settings::instance()->isValid() )

src/calamares/progresstree/ProgressTreeDelegate.cpp

@@ -25,50 +25,8 @@ item_fontsize()
     return CalamaresUtils::defaultFontSize() + 4;
 }
 
-QSize
-ProgressTreeDelegate::sizeHint( const QStyleOptionViewItem& option, const QModelIndex& index ) const
-{
-    if ( !index.isValid() )
-    {
-        return option.rect.size();
-    }
-
-    QFont font = qApp->font();
-
-    font.setPointSize( item_fontsize() );
-    QFontMetrics fm( font );
-    int height = fm.height();
-
-    height += 2 * item_margin;
-
-    return QSize( option.rect.width(), height );
-}
-
-
-void
-ProgressTreeDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
-{
-    QStyleOptionViewItem opt = option;
-
-    painter->save();
-
-    initStyleOption( &opt, index );
-    opt.text.clear();
-
-    painter->setBrush(
-        QColor( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarBackground ) ) );
-    painter->setPen( QColor( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarText ) ) );
-
-    paintViewStep( painter, opt, index );
-
-    painter->restore();
-}
-
-
-void
-ProgressTreeDelegate::paintViewStep( QPainter* painter,
-                                     const QStyleOptionViewItem& option,
-                                     const QModelIndex& index ) const
+static void
+paintViewStep( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index )
 {
     QRect textRect = option.rect.adjusted( item_margin, item_margin, -item_margin, -item_margin );
     QFont font = qApp->font();
@@ -78,9 +36,9 @@ ProgressTreeDelegate::paintViewStep( QPainter* painter,
 
     if ( index.row() == index.data( Calamares::ViewManager::ProgressTreeItemCurrentIndex ).toInt() )
     {
-        painter->setPen( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarTextSelect ) );
+        painter->setPen( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarTextCurrent ) );
         QString textHighlight
-            = Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarTextHighlight );
+            = Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarBackgroundCurrent );
         if ( textHighlight.isEmpty() )
         {
             painter->setBrush( CalamaresApplication::instance()->mainWindow()->palette().window() );
@@ -122,3 +80,42 @@ ProgressTreeDelegate::paintViewStep( QPainter* painter,
         }
     } while ( shrinkSteps <= maximumShrink );
 }
+
+QSize
+ProgressTreeDelegate::sizeHint( const QStyleOptionViewItem& option, const QModelIndex& index ) const
+{
+    if ( !index.isValid() )
+    {
+        return option.rect.size();
+    }
+
+    QFont font = qApp->font();
+
+    font.setPointSize( item_fontsize() );
+    QFontMetrics fm( font );
+    int height = fm.height();
+
+    height += 2 * item_margin;
+
+    return QSize( option.rect.width(), height );
+}
+
+
+void
+ProgressTreeDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
+{
+    QStyleOptionViewItem opt = option;
+
+    painter->save();
+
+    initStyleOption( &opt, index );
+    opt.text.clear();
+
+    painter->setBrush(
+        QColor( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarBackground ) ) );
+    painter->setPen( QColor( Calamares::Branding::instance()->styleString( Calamares::Branding::SidebarText ) ) );
+
+    paintViewStep( painter, opt, index );
+
+    painter->restore();
+}

src/calamares/progresstree/ProgressTreeDelegate.h

@@ -26,9 +26,6 @@ public:
 protected:
     QSize sizeHint( const QStyleOptionViewItem& option, const QModelIndex& index ) const override;
     void paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const override;
-
-private:
-    void paintViewStep( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const;
 };
 
 #endif  // PROGRESSTREEDELEGATE_H

src/calamares/progresstree/ProgressTreeView.h

@@ -14,8 +14,11 @@
 #include <QListView>
 
 /**
- * @brief The ProgressTreeView class is a modified QTreeView which displays the
+ * @brief Displays progress through the list of (visible) steps
+ *
+ * The ProgressTreeView class is a modified QListView which displays the
  * available view steps and the user's progress through them.
+ * Since Calamares doesn't support "sub steps", it isn't really a tree.
  */
 class ProgressTreeView : public QListView
 {

src/libcalamares/CMakeLists.txt

@@ -10,20 +10,16 @@
 # (non-GUI) jobs.
 #
 
-add_definitions( -DDLLEXPORT_PRO )
-include_directories( ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} )
+add_definitions(-DDLLEXPORT_PRO)
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
 
-configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/CalamaresConfig.h.in
-                ${CMAKE_CURRENT_BINARY_DIR}/CalamaresConfig.h )
-configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/CalamaresVersion.h.in
-                ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersion.h )
-configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/CalamaresVersionX.h.in
-                ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersionX.h )
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CalamaresConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/CalamaresConfig.h)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CalamaresVersion.h.in ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersion.h)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CalamaresVersionX.h.in ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersionX.h)
 
-set( OPTIONAL_PRIVATE_LIBRARIES "" )
-set( OPTIONAL_PUBLIC_LIBRARIES "" )
-
-set( libSources
+add_library(
+    calamares
+    SHARED
     CalamaresAbout.cpp
     CppJob.cpp
     GlobalStorage.cpp
@@ -32,13 +28,11 @@ set( libSources
     JobQueue.cpp
     ProcessJob.cpp
     Settings.cpp
-
     # GeoIP services
     geoip/Interface.cpp
     geoip/GeoIPFixed.cpp
     geoip/GeoIPJSON.cpp
     geoip/Handler.cpp
-
     # Locale-data service
     locale/Global.cpp
     locale/Lookup.cpp
@@ -47,7 +41,6 @@ set( libSources
     locale/TranslatableString.cpp
     locale/Translation.cpp
     locale/TranslationsModel.cpp
-
     # Modules
     modulesystem/Config.cpp
     modulesystem/Descriptor.cpp
@@ -56,19 +49,15 @@ set( libSources
     modulesystem/Preset.cpp
     modulesystem/RequirementsChecker.cpp
     modulesystem/RequirementsModel.cpp
-
     # Network service
     network/Manager.cpp
-
     # Packages service
     packages/Globals.cpp
-
     # Partition service
     partition/Global.cpp
     partition/Mount.cpp
     partition/PartitionSize.cpp
     partition/Sync.cpp
-
     # Utility service
     utils/CalamaresUtilsSystem.cpp
     utils/CommandList.cpp
@@ -80,248 +69,197 @@ set( libSources
     utils/Retranslator.cpp
     utils/Runner.cpp
     utils/String.cpp
+    utils/StringExpander.cpp
     utils/UMask.cpp
     utils/Variant.cpp
     utils/Yaml.cpp
 )
 
+set_target_properties(
+    calamares
+    PROPERTIES
+        VERSION ${CALAMARES_VERSION_SHORT}
+        SOVERSION ${CALAMARES_VERSION_SHORT}
+        INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_INSTALL_FULL_INCLUDEDIR}/libcalamares
+)
+target_link_libraries(calamares LINK_PUBLIC yamlcpp::yamlcpp Qt5::Core KF5::CoreAddons)
+
 ### OPTIONAL Automount support (requires dbus)
 #
 #
-if( Qt5DBus_FOUND)
-    list( APPEND libSources partition/AutoMount.cpp )
-    list( APPEND OPTIONAL_PRIVATE_LIBRARIES Qt5::DBus )
+if(Qt5DBus_FOUND)
+    target_sources(calamares PRIVATE partition/AutoMount.cpp)
+    target_link_libraries(calamares PRIVATE Qt5::DBus)
 endif()
 
 ### OPTIONAL Python support
 #
 #
-if( WITH_PYTHON )
-    list( APPEND libSources
-        PythonHelper.cpp
-        PythonJob.cpp
-        PythonJobApi.cpp
-    )
-
-    include_directories(${PYTHON_INCLUDE_DIRS})
-    link_directories(${PYTHON_LIBRARIES})
-
-    include_directories(${Boost_INCLUDE_DIRS})
-    link_directories(${Boost_LIBRARY_DIRS})
-
-    list( APPEND OPTIONAL_PRIVATE_LIBRARIES
-        ${PYTHON_LIBRARIES}
-        ${Boost_LIBRARIES}
-    )
+if(WITH_PYTHON)
+    target_sources(calamares PRIVATE PythonHelper.cpp PythonJob.cpp PythonJobApi.cpp)
+    target_link_libraries(calamares PRIVATE Python::Python Boost::python)
 endif()
 
 ### OPTIONAL GeoIP XML support
 #
 #
 find_package(Qt5 COMPONENTS Xml)
-if( Qt5Xml_FOUND )
-    list( APPEND libSources geoip/GeoIPXML.cpp )
-    list( APPEND OPTIONAL_PUBLIC_LIBRARIES Qt5::Network Qt5::Xml )
+if(Qt5Xml_FOUND)
+    target_sources(calamares PRIVATE geoip/GeoIPXML.cpp)
+    target_link_libraries(calamares PRIVATE Qt5::Network Qt5::Xml)
 endif()
 
 ### OPTIONAL KPMcore support
 #
 #
-include( KPMcoreHelper )
+include(KPMcoreHelper)
 
-if ( KPMcore_FOUND )
-    find_package( Qt5 REQUIRED DBus )  # Needed for KPMCore
-    find_package( KF5 REQUIRED I18n WidgetsAddons )  # Needed for KPMCore
+if(KPMcore_FOUND)
+    find_package(Qt5 REQUIRED DBus) # Needed for KPMCore
+    find_package(KF5 REQUIRED I18n WidgetsAddons) # Needed for KPMCore
 
-    foreach ( d ${KPMcore_API_DEFINITIONS} )
-        add_definitions( -D${d} )
+    foreach(d ${KPMcore_API_DEFINITIONS})
+        add_definitions(-D${d})
     endforeach()
-    include_directories( ${KPMCORE_INCLUDE_DIR} )
-    list( APPEND libSources
-        partition/FileSystem.cpp
-        partition/KPMManager.cpp
-        partition/PartitionIterator.cpp
-        partition/PartitionQuery.cpp
+    include_directories(${KPMCORE_INCLUDE_DIR})
+    target_sources(
+        calamares
+        PRIVATE
+            partition/FileSystem.cpp
+            partition/KPMManager.cpp
+            partition/PartitionIterator.cpp
+            partition/PartitionQuery.cpp
     )
-    list( APPEND OPTIONAL_PRIVATE_LIBRARIES kpmcore )
+    target_link_libraries(calamares PRIVATE kpmcore)
 endif()
 
 ### LIBRARY
 #
 #
-add_library( calamares SHARED ${libSources} )
-set_target_properties( calamares
-    PROPERTIES
-        VERSION ${CALAMARES_VERSION_SHORT}
-        SOVERSION ${CALAMARES_VERSION_SHORT}
-        INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_INSTALL_FULL_INCLUDEDIR}/libcalamares
-)
 calamares_automoc( calamares )
-
-target_link_libraries( calamares
-    LINK_PRIVATE
-        ${OPTIONAL_PRIVATE_LIBRARIES}
-    LINK_PUBLIC
-        yamlcpp::yamlcpp
-        Qt5::Core
-        KF5::CoreAddons
-        ${OPTIONAL_PUBLIC_LIBRARIES}
-)
-
 add_library(Calamares::calamares ALIAS calamares)
 
 ### Installation
 #
 #
-install( TARGETS calamares
+install(
+    TARGETS calamares
     EXPORT Calamares
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME
+    DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}
 )
 
 # Make symlink lib/calamares/libcalamares.so to lib/libcalamares.so.VERSION so
 # lib/calamares can be used as module path for the Python interpreter.
-install( CODE "
+install(
+    CODE
+        "
     file( MAKE_DIRECTORY \"\$ENV{DESTDIR}/${CMAKE_INSTALL_FULL_LIBDIR}/calamares\" )
     execute_process( COMMAND \"${CMAKE_COMMAND}\" -E create_symlink ../libcalamares.so.${CALAMARES_VERSION_SHORT} libcalamares.so WORKING_DIRECTORY \"\$ENV{DESTDIR}/${CMAKE_INSTALL_FULL_LIBDIR}/calamares\" )
-")
+"
+)
 
 # Install header files
-file( GLOB rootHeaders "*.h" )
+file(GLOB rootHeaders "*.h")
 install(
-    FILES
-        ${CMAKE_CURRENT_BINARY_DIR}/CalamaresConfig.h
-        ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersion.h
-        ${rootHeaders}
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/CalamaresConfig.h ${CMAKE_CURRENT_BINARY_DIR}/CalamaresVersion.h ${rootHeaders}
     DESTINATION include/libcalamares
 )
 # Install each subdir-worth of header files
-foreach( subdir geoip locale modulesystem network partition utils )
-    file( GLOB subdir_headers "${subdir}/*.h" )
-    install( FILES ${subdir_headers} DESTINATION include/libcalamares/${subdir} )
+foreach(subdir geoip locale modulesystem network partition utils)
+    file(GLOB subdir_headers "${subdir}/*.h")
+    install(FILES ${subdir_headers} DESTINATION include/libcalamares/${subdir})
 endforeach()
 
-
-### TESTING
+### TRANSLATION TESTING
 #
-#
-calamares_add_test(
-    libcalamarestest
-    SOURCES
-        Tests.cpp
-)
+# This is a support function, used just once, to help out the localetest
+function(calamares_qrc_translations basename)
+    set(NAME ${ARGV0})
+    set(options "")
+    set(oneValueArgs SUBDIRECTORY OUTPUT_VARIABLE)
+    set(multiValueArgs LANGUAGES)
+    cmake_parse_arguments(_qrt "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-calamares_add_test(
-    libcalamaresgeoiptest
-    SOURCES
-        geoip/GeoIPTests.cpp
-        ${geoip_src}
-)
-
-function ( calamares_qrc_translations basename )
-    set( NAME ${ARGV0} )
-    set( options "" )
-    set( oneValueArgs SUBDIRECTORY OUTPUT_VARIABLE )
-    set( multiValueArgs LANGUAGES )
-    cmake_parse_arguments( _qrt "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
-
-    if( NOT _qrt_OUTPUT_VARIABLE )
-        set( _qrt_OUTPUT_VARIABLE "qrc_translations_${basename}" )
+    if(NOT _qrt_OUTPUT_VARIABLE)
+        set(_qrt_OUTPUT_VARIABLE "qrc_translations_${basename}")
     endif()
 
-    set( translations_qrc_infile ${CMAKE_CURRENT_BINARY_DIR}/${basename}.qrc )
-    set( translations_qrc_outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${basename}.cxx )
+    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} )
-        string( APPEND calamares_i18n_qrc_content "<file>${basename}_${lang}.qm</file>" )
-        list( APPEND calamares_i18n_ts_filelist "${CMAKE_CURRENT_SOURCE_DIR}/${_qrt_SUBDIRECTORY}/${basename}_${lang}.ts" )
+    set(calamares_i18n_qrc_content "")
+    set(calamares_i18n_ts_filelist "")
+    foreach(lang ${_qrt_LANGUAGES})
+        string(APPEND calamares_i18n_qrc_content "<file>${basename}_${lang}.qm</file>")
+        list(
+            APPEND
+            calamares_i18n_ts_filelist
+            "${CMAKE_CURRENT_SOURCE_DIR}/${_qrt_SUBDIRECTORY}/${basename}_${lang}.ts"
+        )
     endforeach()
 
-    configure_file( ${CMAKE_SOURCE_DIR}/lang/calamares_i18n.qrc.in ${translations_qrc_infile} @ONLY )
+    configure_file(${CMAKE_SOURCE_DIR}/lang/calamares_i18n.qrc.in ${translations_qrc_infile} @ONLY)
     qt5_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 "${Qt5Core_RCC_EXECUTABLE}"
-        ARGS ${rcc_options} --format-version 1 -name ${basename} -o ${translations_qrc_outfile} ${translations_qrc_infile}
+        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 )
+    set(${_qrt_OUTPUT_VARIABLE} ${translations_qrc_outfile} PARENT_SCOPE)
 endfunction()
 
 calamares_qrc_translations( localetest OUTPUT_VARIABLE localetest_qrc SUBDIRECTORY testdata LANGUAGES nl )
-calamares_add_test(
-    libcalamareslocaletest
-    SOURCES
-        locale/Tests.cpp
-        ${localetest_qrc}
-)
 
-calamares_add_test(
-    libcalamaresmodulesystemtest
-    SOURCES
-        modulesystem/Tests.cpp
-)
+### TESTING
+#
+#
+calamares_add_test(libcalamarestest SOURCES Tests.cpp)
 
-calamares_add_test(
-    libcalamaresnetworktest
-    SOURCES
-        network/Tests.cpp
-)
+calamares_add_test(libcalamaresgeoiptest SOURCES geoip/GeoIPTests.cpp ${geoip_src})
 
-calamares_add_test(
-    libcalamarespackagestest
-    SOURCES
-        packages/Tests.cpp
-)
+calamares_add_test(libcalamareslocaletest SOURCES locale/Tests.cpp ${localetest_qrc})
 
-calamares_add_test(
-    libcalamarespartitiontest
-    SOURCES
-        partition/Global.cpp
-        partition/Tests.cpp
-    LIBRARIES
-        ${OPTIONAL_PRIVATE_LIBRARIES}
-)
+calamares_add_test(libcalamaresmodulesystemtest SOURCES modulesystem/Tests.cpp)
 
-if( KPMcore_FOUND )
-    calamares_add_test(
-        libcalamarespartitionkpmtest
-        SOURCES
-            partition/KPMTests.cpp
-        LIBRARIES
-            ${OPTIONAL_PRIVATE_LIBRARIES}
-    )
+calamares_add_test(libcalamaresnetworktest SOURCES network/Tests.cpp)
+
+calamares_add_test(libcalamarespackagestest SOURCES packages/Tests.cpp)
+
+if(KPMcore_FOUND)
+    calamares_add_test(libcalamarespartitiontest SOURCES partition/Global.cpp partition/Tests.cpp LIBRARIES kpmcore)
+    calamares_add_test(libcalamarespartitionkpmtest SOURCES partition/KPMTests.cpp LIBRARIES kpmcore)
 endif()
 
-calamares_add_test(
-    libcalamaresutilstest
-    SOURCES
-        utils/Tests.cpp
-        utils/Runner.cpp
-)
-
-calamares_add_test(
-    libcalamaresutilspathstest
-    SOURCES
-        utils/TestPaths.cpp
-)
+calamares_add_test(libcalamaresutilstest SOURCES utils/Tests.cpp utils/Runner.cpp)
 
+calamares_add_test(libcalamaresutilspathstest SOURCES utils/TestPaths.cpp)
 
 # This is not an actual test, it's a test / demo application
 # for experimenting with GeoIP.
-add_executable( test_geoip geoip/test_geoip.cpp ${geoip_src} )
-target_link_libraries( test_geoip Calamares::calamares Qt5::Network yamlcpp::yamlcpp )
+add_executable(test_geoip geoip/test_geoip.cpp ${geoip_src})
+target_link_libraries(test_geoip Calamares::calamares Qt5::Network yamlcpp::yamlcpp)
 calamares_automoc( test_geoip )
 
-if ( Qt5DBus_FOUND )
-    add_executable( test_automount partition/calautomount.cpp )
-    target_link_libraries( test_automount Calamares::calamares Qt5::DBus )
+if(Qt5DBus_FOUND)
+    add_executable(test_automount partition/calautomount.cpp)
+    target_link_libraries(test_automount Calamares::calamares Qt5::DBus)
 endif()

src/libcalamares/CalamaresAbout.cpp

@@ -9,7 +9,7 @@
 
 #include "CalamaresAbout.h"
 
-#include "CalamaresVersion.h"
+#include "CalamaresVersionX.h"
 
 #include <QCoreApplication>
 

src/libcalamares/CalamaresConfig.h.in

@@ -25,7 +25,6 @@
  * which is the CMake-time side of the same configuration.
  */
 #cmakedefine WITH_PYTHON
-#cmakedefine WITH_PYTHONQT
 #cmakedefine WITH_QML
 
 #endif  // CALAMARESCONFIG_H

src/libcalamares/CalamaresVersionX.h.in

@@ -11,6 +11,6 @@
 #include "CalamaresVersion.h"
 
 #undef CALAMARES_VERSION
-#cmakedefine CALAMARES_VERSION "${CALAMARES_VERSION}"
+#cmakedefine CALAMARES_VERSION "${CALAMARES_VERSION_LONG}"
 
 #endif  // CALAMARES_VERSION_H

src/libcalamares/PythonHelper.h

@@ -19,7 +19,7 @@
 namespace Calamares
 {
 class GlobalStorage;
-}
+}  // namespace Calamares
 
 namespace CalamaresPython
 {

src/libcalamares/PythonJobApi.cpp

@@ -263,7 +263,7 @@ host_env_process_output( const boost::python::list& args,
 std::string
 obscure( const std::string& string )
 {
-    return CalamaresUtils::obscure( QString::fromStdString( string ) ).toStdString();
+    return Calamares::String::obscure( QString::fromStdString( string ) ).toStdString();
 }
 
 static QStringList

src/libcalamares/PythonJobApi.h

@@ -18,7 +18,7 @@
 namespace Calamares
 {
 class PythonJob;
-}
+}  // namespace Calamares
 
 namespace CalamaresPython
 {

src/libcalamares/locale/Global.h

@@ -28,7 +28,7 @@
 namespace Calamares
 {
 class GlobalStorage;
-}
+}  // namespace Calamares
 
 namespace CalamaresUtils
 {

src/libcalamares/modulesystem/Descriptor.cpp

@@ -40,7 +40,6 @@ interfaceNames()
         { QStringLiteral("process"), Interface::Process },
         { QStringLiteral("qtplugin"), Interface::QtPlugin },
         { QStringLiteral("python"), Interface::Python },
-        { QStringLiteral("pythonqt"), Interface::PythonQt }
     };
     // *INDENT-ON*
     // clang-format on
@@ -107,7 +106,6 @@ Descriptor::fromDescriptorData( const QVariantMap& moduleDesc, const QString& de
         consumedKeys << "load";
         break;
     case Interface::Python:
-    case Interface::PythonQt:
         d.m_script = CalamaresUtils::getString( moduleDesc, "script" );
         if ( d.m_script.isEmpty() )
         {

src/libcalamares/modulesystem/Descriptor.h

@@ -42,7 +42,6 @@ enum class Interface
     QtPlugin,  // Jobs or Views
     Python,  // Jobs only
     Process,  // Deprecated interface
-    PythonQt  // Views only, available as enum even if PythonQt isn't used
 };
 const NamedEnumTable< Interface >& interfaceNames();
 
@@ -112,10 +111,7 @@ public:
      *
      * Python job modules have one specific script to load and run.
      */
-    QString script() const
-    {
-        return ( m_interface == Interface::Python || m_interface == Interface::PythonQt ) ? m_script : QString();
-    }
+    QString script() const { return m_interface == Interface::Python ? m_script : QString(); }
 
 private:
     QString m_name;

src/libcalamares/modulesystem/RequirementsChecker.cpp

@@ -43,7 +43,7 @@ RequirementsChecker::run()
 {
     m_progressTimer = new QTimer( this );
     connect( m_progressTimer, &QTimer::timeout, this, &RequirementsChecker::reportProgress );
-    m_progressTimer->start( 1200 );  // msec
+    m_progressTimer->start( std::chrono::milliseconds( 1200 ) );
 
     for ( const auto& module : m_modules )
     {
@@ -76,7 +76,7 @@ RequirementsChecker::finished()
         }
 
         m_model->describe();
-        m_model->changeRequirementsList();
+        m_model->reCheckList();
         QTimer::singleShot( 0, this, &RequirementsChecker::done );
     }
 }
@@ -91,7 +91,7 @@ RequirementsChecker::addCheckedRequirements( Module* m )
         m_model->addRequirementsList( l );
     }
 
-    requirementsProgress( tr( "Requirements checking for module <i>%1</i> is complete." ).arg( m->name() ) );
+    Q_EMIT requirementsProgress( tr( "Requirements checking for module '%1' is complete." ).arg( m->name() ) );
 }
 
 void
@@ -117,11 +117,11 @@ RequirementsChecker::reportProgress()
         unsigned int posInterval = ( m_progressTimer->interval() < 0 ) ? 1000 : uint( m_progressTimer->interval() );
         QString waiting = tr( "Waiting for %n module(s).", "", remaining );
         QString elapsed = tr( "(%n second(s))", "", m_progressTimeouts * posInterval / 1000 );
-        emit requirementsProgress( waiting + QString( " " ) + elapsed );
+        Q_EMIT requirementsProgress( waiting + QString( " " ) + elapsed );
     }
     else
     {
-        emit requirementsProgress( tr( "System-requirements checking is complete." ) );
+        Q_EMIT requirementsProgress( tr( "System-requirements checking is complete." ) );
     }
 }
 

src/libcalamares/modulesystem/RequirementsModel.cpp

@@ -16,17 +16,41 @@ namespace Calamares
 {
 
 void
-RequirementsModel::addRequirementsList( const Calamares::RequirementsList& requirements )
+RequirementsModel::clear()
 {
     QMutexLocker l( &m_addLock );
     beginResetModel();
-    m_requirements.append( requirements );
-    changeRequirementsList();
+    m_requirements.clear();
     endResetModel();
+    reCheckList();
 }
 
 void
-RequirementsModel::changeRequirementsList()
+RequirementsModel::addRequirementsList( const Calamares::RequirementsList& requirements )
+{
+    QMutexLocker l( &m_addLock );
+
+    beginResetModel();
+    for ( const auto& r : requirements )
+    {
+        auto it = std::find_if( m_requirements.begin(),
+                                m_requirements.end(),
+                                [ &r ]( const Calamares::RequirementEntry& re ) { return r.name == re.name; } );
+        if ( it != m_requirements.end() )
+        {
+            *it = r;
+        }
+        else
+        {
+            m_requirements.append( r );
+        }
+    }
+    endResetModel();
+    reCheckList();
+}
+
+void
+RequirementsModel::reCheckList()
 {
     auto isUnSatisfied = []( const Calamares::RequirementEntry& e ) { return !e.satisfied; };
     auto isMandatoryAndUnSatisfied = []( const Calamares::RequirementEntry& e ) { return e.mandatory && !e.satisfied; };
@@ -34,8 +58,8 @@ RequirementsModel::changeRequirementsList()
     m_satisfiedRequirements = std::none_of( m_requirements.begin(), m_requirements.end(), isUnSatisfied );
     m_satisfiedMandatory = std::none_of( m_requirements.begin(), m_requirements.end(), isMandatoryAndUnSatisfied );
 
-    emit satisfiedRequirementsChanged( m_satisfiedRequirements );
-    emit satisfiedMandatoryChanged( m_satisfiedMandatory );
+    Q_EMIT satisfiedRequirementsChanged( m_satisfiedRequirements );
+    Q_EMIT satisfiedMandatoryChanged( m_satisfiedMandatory );
 }
 
 int
@@ -98,7 +122,7 @@ void
 RequirementsModel::setProgressMessage( const QString& m )
 {
     m_progressMessage = m;
-    emit progressMessageChanged( m_progressMessage );
+    Q_EMIT progressMessageChanged( m_progressMessage );
 }
 
 }  // namespace Calamares

src/libcalamares/modulesystem/RequirementsModel.h

@@ -33,8 +33,6 @@ class RequirementsChecker;
  */
 class DLLEXPORT RequirementsModel : public QAbstractListModel
 {
-    friend class RequirementsChecker;
-
     Q_OBJECT
     Q_PROPERTY( bool satisfiedRequirements READ satisfiedRequirements NOTIFY satisfiedRequirementsChanged FINAL )
     Q_PROPERTY( bool satisfiedMandatory READ satisfiedMandatory NOTIFY satisfiedMandatoryChanged FINAL )
@@ -45,11 +43,11 @@ public:
 
     enum Roles : short
     {
-        Name,
+        NegatedText = Qt::DisplayRole,
+        Details = Qt::ToolTipRole,
+        Name = Qt::UserRole,
         Satisfied,
         Mandatory,
-        Details,
-        NegatedText,
         HasDetails
     };
     // No Q_ENUM because these are exposed through roleNames()
@@ -69,6 +67,15 @@ public:
     ///@brief Debugging tool, describe the checking-state
     void describe() const;
 
+    ///@brief Update progress message (called by the checker)
+    void setProgressMessage( const QString& m );
+
+    ///@brief Append some requirements; resets the model
+    void addRequirementsList( const Calamares::RequirementsList& requirements );
+
+    ///@brief Check the whole list, emit signals satisfied...()
+    void reCheckList();
+
 signals:
     void satisfiedRequirementsChanged( bool value );
     void satisfiedMandatoryChanged( bool value );
@@ -77,16 +84,10 @@ signals:
 protected:
     QHash< int, QByteArray > roleNames() const override;
 
-    ///@brief Append some requirements; resets the model
-    void addRequirementsList( const Calamares::RequirementsList& requirements );
-
-    ///@brief Update progress message (called by the checker)
-    void setProgressMessage( const QString& m );
+    ///@brief Clears the requirements; resets the model
+    void clear();
 
 private:
-    ///@brief Implementation for {set,add}RequirementsList
-    void changeRequirementsList();
-
     QString m_progressMessage;
     QMutex m_addLock;
     RequirementsList m_requirements;

src/libcalamares/network/Manager.cpp

@@ -29,16 +29,11 @@ namespace Network
 void
 RequestOptions::applyToRequest( QNetworkRequest* request ) const
 {
-#if QT_VERSION < QT_VERSION_CHECK( 5, 15, 0 )
-    constexpr const auto RedirectPolicyAttribute = QNetworkRequest::FollowRedirectsAttribute;
-#else
-    constexpr const auto RedirectPolicyAttribute = QNetworkRequest::RedirectPolicyAttribute;
-#endif
 
     if ( m_flags & Flag::FollowRedirect )
     {
         // Follows all redirects except unsafe ones (https to http).
-        request->setAttribute( RedirectPolicyAttribute, true );
+        request->setAttribute( QNetworkRequest::RedirectPolicyAttribute, true );
     }
 
     if ( m_flags & Flag::FakeUserAgent )

src/libcalamares/partition/Global.h

@@ -17,13 +17,10 @@
 #define PARTITION_GLOBAL_H
 
 #include "DllMacro.h"
+#include "FileSystem.h"
 #include "JobQueue.h"
 
-#ifdef WITH_KPMCORE4API
-#include "FileSystem.h"
-
 #include <kpmcore/fs/filesystem.h>
-#endif
 
 namespace CalamaresUtils
 {
@@ -78,7 +75,6 @@ isFilesystemUsedGS( const QString& filesystemType )
     return isFilesystemUsedGS( Calamares::JobQueue::instanceGlobalStorage(), filesystemType );
 }
 
-#ifdef WITH_KPMCORE4API
 /** @brief Mark a particular filesystem type as used (or not)
  *
  * See useFilesystemGS(const QString&, bool); this method uses the filesystem type
@@ -100,7 +96,6 @@ isFilesystemUsedGS( FileSystem::Type filesystem )
     return isFilesystemUsedGS( untranslatedFS( filesystem ) );
 }
 
-#endif
 }  // namespace Partition
 }  // namespace CalamaresUtils
 

src/libcalamares/partition/KPMHelper.h

@@ -25,6 +25,8 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 #pragma clang diagnostic ignored "-Wsuggest-destructor-override"
 #pragma clang diagnostic ignored "-Winconsistent-missing-destructor-override"
+// Because of __lastType
+#pragma clang diagnostic ignored "-Wreserved-identifier"
 #endif
 
 #include <backend/corebackend.h>

src/libcalamares/partition/KPMManager.cpp

@@ -14,10 +14,7 @@
 
 #include <kpmcore/backend/corebackend.h>
 #include <kpmcore/backend/corebackendmanager.h>
-#if defined( WITH_KPMCORE4API )
 #include <kpmcore/util/externalcommand.h>
-#endif
-
 
 #include <QObject>
 
@@ -30,7 +27,6 @@ class InternalManager
 {
 public:
     InternalManager();
-    ~InternalManager();
 };
 
 static bool s_kpm_loaded = false;
@@ -69,22 +65,6 @@ InternalManager::InternalManager()
     }
 }
 
-InternalManager::~InternalManager()
-{
-#if defined( WITH_KPMCORE4API ) && !defined( WITH_KPMCORE42API )
-    cDebug() << "Cleaning up KPMCore backend ..";
-
-    // From KPMcore 4.0 until KPMcore 4.2 we needed to stop
-    // the helper by hand. KPMcore 4.2 ported to polkit directly,
-    // which doesn't need a helper.
-    auto backend_p = CoreBackendManager::self()->backend();
-    if ( backend_p )
-    {
-        ExternalCommand::stopHelper();
-    }
-#endif
-}
-
 std::shared_ptr< InternalManager >
 getInternal()
 {

src/libcalamares/partition/KPMTests.cpp

@@ -57,18 +57,10 @@ KPMTests::testFlagNames()
 
     QCOMPARE( PartitionTable::flagName( static_cast< PartitionTable::Flag >( 1 ) ), QStringLiteral( "boot" ) );
 
-#ifdef WITH_KPMCORE4API
     // KPMCore 4 unifies the flags and handles them internally
     QCOMPARE( PartitionTable::flagName( PartitionTable::Flag::Boot ), QStringLiteral( "boot" ) );
     QVERIFY( names.contains( QStringLiteral( "boot" ) ) );
     QVERIFY( !names.contains( QStringLiteral( "esp" ) ) );
-#else
-    // KPMCore 3 has separate flags
-    QCOMPARE( PartitionTable::flagName( PartitionTable::FlagBoot ), QStringLiteral( "boot" ) );
-    QCOMPARE( PartitionTable::flagName( PartitionTable::FlagEsp ), QStringLiteral( "esp" ) );
-    QVERIFY( names.contains( QStringLiteral( "boot" ) ) );
-    QVERIFY( names.contains( QStringLiteral( "esp" ) ) );
-#endif
 }
 
 void

src/libcalamares/partition/PartitionQuery.cpp

@@ -50,12 +50,7 @@ isPartitionFreeSpace( const Partition* partition )
 bool
 isPartitionNew( const Partition* partition )
 {
-#if defined( WITH_KPMCORE4API )
-    constexpr auto NewState = Partition::State::New;
-#else
-    constexpr auto NewState = Partition::StateNew;
-#endif
-    return partition->state() == NewState;
+    return partition->state() == Partition::State::New;
 }
 
 

src/libcalamares/utils/CalamaresUtilsSystem.cpp

@@ -230,7 +230,7 @@ System::createTargetParentDirs( const QString& filePath ) const
 }
 
 
-QPair< qint64, qreal >
+QPair< quint64, qreal >
 System::getTotalMemoryB() const
 {
 #ifdef Q_OS_LINUX

src/libcalamares/utils/CalamaresUtilsSystem.h

@@ -337,7 +337,7 @@ public:
      *
      * @return size, guesstimate-factor
      */
-    DLLEXPORT QPair< qint64, qreal > getTotalMemoryB() const;
+    DLLEXPORT QPair< quint64, qreal > getTotalMemoryB() const;
 
     /**
      * @brief getCpuDescription returns a string describing the CPU.

src/libcalamares/utils/CommandList.cpp

@@ -16,6 +16,7 @@
 // #include "utils/CalamaresUtils.h"
 #include "utils/CalamaresUtilsSystem.h"
 #include "utils/Logger.h"
+#include "utils/StringExpander.h"
 #include "utils/Variant.h"
 
 #include <QCoreApplication>
@@ -67,6 +68,48 @@ get_variant_stringlist( const QVariantList& l )
     return retl;
 }
 
+static Calamares::String::DictionaryExpander
+get_gs_expander( System::RunLocation location )
+{
+    Calamares::GlobalStorage* gs = Calamares::JobQueue::instance()->globalStorage();
+
+    Calamares::String::DictionaryExpander expander;
+
+    // Figure out the replacement for ${ROOT}
+    if ( location == System::RunLocation::RunInTarget )
+    {
+        expander.insert( QStringLiteral( "ROOT" ), QStringLiteral( "/" ) );
+    }
+    else if ( gs && gs->contains( "rootMountPoint" ) )
+    {
+        expander.insert( QStringLiteral( "ROOT" ), gs->value( "rootMountPoint" ).toString() );
+    }
+
+    // Replacement for ${USER}
+    if ( gs && gs->contains( "username" ) )
+    {
+        expander.insert( QStringLiteral( "USER" ), gs->value( "username" ).toString() );
+    }
+
+    return expander;
+}
+
+CommandLine
+CommandLine::expand( KMacroExpanderBase& expander ) const
+{
+    QString c = first;
+    expander.expandMacrosShellQuote( c );
+    return { c, second };
+}
+
+CalamaresUtils::CommandLine
+CommandLine::expand() const
+{
+    auto expander = get_gs_expander( System::RunLocation::RunInHost );
+    return expand( expander );
+}
+
+
 CommandList::CommandList( bool doChroot, std::chrono::seconds timeout )
     : m_doChroot( doChroot )
     , m_timeout( timeout )
@@ -90,7 +133,7 @@ CommandList::CommandList::CommandList( const QVariant& v, bool doChroot, std::ch
     }
     else if ( v.type() == QVariant::String )
     {
-        append( v.toString() );
+        append( { v.toString(), m_timeout } );
     }
     else if ( v.type() == QVariant::Map )
     {
@@ -107,61 +150,28 @@ CommandList::CommandList::CommandList( const QVariant& v, bool doChroot, std::ch
     }
 }
 
-CommandList::~CommandList() {}
-
-static inline bool
-findInCommands( const CommandList& l, const QString& needle )
-{
-    for ( CommandList::const_iterator i = l.cbegin(); i != l.cend(); ++i )
-        if ( i->command().contains( needle ) )
-        {
-            return true;
-        }
-    return false;
-}
-
 Calamares::JobResult
 CommandList::run()
 {
-    QLatin1String rootMagic( "@@ROOT@@" );
-    QLatin1String userMagic( "@@USER@@" );
-
     System::RunLocation location = m_doChroot ? System::RunLocation::RunInTarget : System::RunLocation::RunInHost;
 
-    /* Figure out the replacement for @@ROOT@@ */
-    QString root = QStringLiteral( "/" );
-    Calamares::GlobalStorage* gs = Calamares::JobQueue::instance()->globalStorage();
-
-    bool needsRootSubstitution = findInCommands( *this, rootMagic );
-    if ( needsRootSubstitution && ( location == System::RunLocation::RunInHost ) )
+    auto expander = get_gs_expander( location );
+    auto expandedList = expand( expander );
+    if ( expander.hasErrors() )
     {
-        if ( !gs || !gs->contains( "rootMountPoint" ) )
-        {
-            cError() << "No rootMountPoint defined.";
-            return Calamares::JobResult::error(
-                QCoreApplication::translate( "CommandList", "Could not run command." ),
-                QCoreApplication::translate( "CommandList",
-                                             "The command runs in the host environment and needs to know the root "
-                                             "path, but no rootMountPoint is defined." ) );
-        }
-        root = gs->value( "rootMountPoint" ).toString();
-    }
-
-    bool needsUserSubstitution = findInCommands( *this, userMagic );
-    if ( needsUserSubstitution && ( !gs || !gs->contains( "username" ) ) )
-    {
-        cError() << "No username defined.";
+        const auto missing = expander.errorNames();
+        cError() << "Missing variables:" << missing;
         return Calamares::JobResult::error(
             QCoreApplication::translate( "CommandList", "Could not run command." ),
             QCoreApplication::translate( "CommandList",
-                                         "The command needs to know the user's name, but no username is defined." ) );
+                                         "The commands use variables that are not defined. "
+                                         "Missing variables are: %1." )
+                .arg( missing.join( ',' ) ) );
     }
-    QString user = gs->value( "username" ).toString();  // may be blank if unset
 
-    for ( CommandList::const_iterator i = cbegin(); i != cend(); ++i )
+    for ( CommandList::const_iterator i = expandedList.cbegin(); i != expandedList.cend(); ++i )
     {
         QString processed_cmd = i->command();
-        processed_cmd.replace( rootMagic, root ).replace( userMagic, user );
         bool suppress_result = false;
         if ( processed_cmd.startsWith( '-' ) )
         {
@@ -191,10 +201,24 @@ CommandList::run()
     return Calamares::JobResult::ok();
 }
 
-void
-CommandList::append( const QString& s )
+CommandList
+CommandList::expand( KMacroExpanderBase& expander ) const
 {
-    append( CommandLine( s, m_timeout ) );
+    // Copy and expand the list, collecting missing variables (so don't call expand())
+    CommandList expandedList( m_doChroot, m_timeout );
+    std::transform( cbegin(),
+                    cend(),
+                    std::back_inserter( expandedList ),
+                    [ &expander ]( const CommandLine& c ) { return c.expand( expander ); } );
+    return expandedList;
 }
 
+CommandList
+CommandList::expand() const
+{
+    auto expander = get_gs_expander( System::RunLocation::RunInHost );
+    return expand( expander );
+}
+
+
 }  // namespace CalamaresUtils

src/libcalamares/utils/CommandList.h

@@ -18,6 +18,8 @@
 
 #include <chrono>
 
+class KMacroExpanderBase;
+
 namespace CalamaresUtils
 {
 
@@ -50,6 +52,20 @@ struct CommandLine : public QPair< QString, std::chrono::seconds >
     std::chrono::seconds timeout() const { return second; }
 
     bool isValid() const { return !first.isEmpty(); }
+
+    /** @brief Returns a copy of this one command, with variables expanded
+     *
+     * The given macro-expander is used to expand the command-line.
+     * This will normally be a Calamares::String::DictionaryExpander
+     * instance, which handles the ROOT and USER variables.
+     */
+    CommandLine expand( KMacroExpanderBase& expander ) const;
+    /** @brief As above, with a default macro-expander.
+     *
+     * The default macro-expander assumes RunInHost (e.g. ROOT will
+     * expand to the RootMountPoint set in Global Storage).
+     */
+    CommandLine expand() const;
 };
 
 /** @brief Abbreviation, used internally. */
@@ -69,7 +85,6 @@ public:
     /** @brief empty command-list with timeout to apply to entries. */
     CommandList( bool doChroot = true, std::chrono::seconds timeout = std::chrono::seconds( 10 ) );
     CommandList( const QVariant& v, bool doChroot = true, std::chrono::seconds timeout = std::chrono::seconds( 10 ) );
-    ~CommandList();
 
     bool doChroot() const { return m_doChroot; }
 
@@ -81,10 +96,21 @@ public:
     using CommandList_t::const_iterator;
     using CommandList_t::count;
     using CommandList_t::isEmpty;
+    using CommandList_t::push_back;
+    using CommandList_t::value_type;
 
-protected:
-    using CommandList_t::append;
-    void append( const QString& );
+    /** @brief Return a copy of this command-list, with variables expanded
+     *
+     * Each command-line in the list is expanded with the given @p expander.
+     * @see CommandLine::expand() for details.
+     */
+    CommandList expand( KMacroExpanderBase& expander ) const;
+    /** @brief As above, with a default macro-expander.
+     *
+     * Each command-line in the list is expanded with that default macro-expander.
+     * @see CommandLine::expand() for details.
+     */
+    CommandList expand() const;
 
 private:
     bool m_doChroot;

src/libcalamares/utils/Logger.cpp

@@ -53,7 +53,14 @@ setupLogLevel( unsigned int level )
     {
         level = LOGVERBOSE;
     }
-    s_threshold = level + 1;  // Comparison is < in log() function
+    s_threshold = level + 1;  // Comparison is < in logLevelEnabled() function
+}
+
+unsigned int
+logLevel()
+{
+    // Undo the +1 in setupLogLevel()
+    return s_threshold > 0 ? s_threshold - 1 : 0;
 }
 
 bool
@@ -62,33 +69,40 @@ logLevelEnabled( unsigned int level )
     return level < s_threshold;
 }
 
-unsigned int
-logLevel()
+/** @brief Should we call the log_implementation() function with this level?
+ *
+ * The implementation logs everything for which logLevelEnabled() is
+ * true to the file **and** to stdout; it logs everything at debug-level
+ * or below to the file regardless.
+ */
+static inline bool
+log_enabled( unsigned int level )
 {
-    return s_threshold > 0 ? s_threshold - 1 : 0;
+    return level <= LOGDEBUG || logLevelEnabled( level );
 }
 
 static void
-log( const char* msg, unsigned int debugLevel, bool withTime = true )
+log_implementation( const char* msg, unsigned int debugLevel, const bool withTime )
 {
+    QMutexLocker lock( &s_mutex );
+
+    const auto date = QDate::currentDate().toString( Qt::ISODate );
+    const auto time = QTime::currentTime().toString();
+
+    // If we don't format the date as a Qt::ISODate then we get a crash when
+    // logging at exit as Qt tries to use QLocale to format, but QLocale is
+    // on its way out.
+    logfile << date.toUtf8().data() << " - " << time.toUtf8().data() << " [" << debugLevel << "]: " << msg << std::endl;
+
+    logfile.flush();
+
     if ( logLevelEnabled( debugLevel ) )
     {
-        QMutexLocker lock( &s_mutex );
-
-        // If we don't format the date as a Qt::ISODate then we get a crash when
-        // logging at exit as Qt tries to use QLocale to format, but QLocale is
-        // on its way out.
-        logfile << QDate::currentDate().toString( Qt::ISODate ).toUtf8().data() << " - "
-                << QTime::currentTime().toString().toUtf8().data() << " ["
-                << QString::number( debugLevel ).toUtf8().data() << "]: " << msg << std::endl;
-
-        logfile.flush();
-
         if ( withTime )
         {
-            std::cout << QTime::currentTime().toString().toUtf8().data() << " ["
-                      << QString::number( debugLevel ).toUtf8().data() << "]: ";
+            std::cout << time.toUtf8().data() << " [" << debugLevel << "]: ";
         }
+        // The endl is desired, since it also flushes (like the logfile, above)
         std::cout << msg << std::endl;
     }
 }
@@ -97,29 +111,30 @@ log( const char* msg, unsigned int debugLevel, bool withTime = true )
 static void
 CalamaresLogHandler( QtMsgType type, const QMessageLogContext&, const QString& msg )
 {
-    static QMutex s_mutex;
-
-    QByteArray ba = msg.toUtf8();
-    const char* message = ba.constData();
-
-    QMutexLocker locker( &s_mutex );
-
+    unsigned int level = LOGVERBOSE;
     switch ( type )
     {
     case QtInfoMsg:
-        log( message, LOGVERBOSE );
+        level = LOGVERBOSE;
         break;
     case QtDebugMsg:
-        log( message, LOGDEBUG );
+        level = LOGDEBUG;
         break;
     case QtWarningMsg:
-        log( message, LOGWARNING );
+        level = LOGWARNING;
         break;
     case QtCriticalMsg:
     case QtFatalMsg:
-        log( message, LOGERROR );
+        level = LOGERROR;
         break;
     }
+
+    if ( !log_enabled( level ) )
+    {
+        return;
+    }
+
+    log_implementation( msg.toUtf8().constData(), level, true );
 }
 
 
@@ -188,14 +203,14 @@ CDebug::CDebug( unsigned int debugLevel, const char* func )
 
 CDebug::~CDebug()
 {
-    if ( logLevelEnabled( m_debugLevel ) )
+    if ( log_enabled( m_debugLevel ) )
     {
         if ( m_funcinfo )
         {
             m_msg.prepend( s_Continuation );  // Prepending, so back-to-front
             m_msg.prepend( m_funcinfo );
         }
-        log( m_msg.toUtf8().data(), m_debugLevel, m_funcinfo );
+        log_implementation( m_msg.toUtf8().data(), m_debugLevel, bool( m_funcinfo ) );
     }
 }
 

src/libcalamares/utils/PluginFactory.h

@@ -4,10 +4,6 @@
  *   SPDX-FileCopyrightText: 2017-2018 Adriaan de Groot <groot@kde.org>
  *   SPDX-License-Identifier: GPL-3.0-or-later
  *
- *   Based on KPluginFactory from KCoreAddons, KDE project
- *   SPDX-FileCopyrightText: 2007 Matthias Kretz <kretz@kde.org>
- *   SPDX-FileCopyrightText: 2007 Bernhard Loos <nhuh.put@web.de>
- *
  *   Calamares is Free Software: see the License-Identifier above.
  *
  *
@@ -16,81 +12,100 @@
 #ifndef UTILS_PLUGINFACTORY_H
 #define UTILS_PLUGINFACTORY_H
 
-#include <KPluginFactory>
+#include <QObject>
 
 #define CalamaresPluginFactory_iid "io.calamares.PluginFactory"
 
 /** @brief Plugin factory for Calamares
  *
- * Try to re-use KPluginFactory as much as possible (since the
- * old code for PluginFactory was a fork of an old version of
- * exactly that).
+ * A Calamares plugin contains just one kind of plugin -- either
+ * a job, or a viewstep -- so the factory is straightforward.
+ * It gets a single CreateInstanceFunction and calls that;
+ * the function is set when registerPlugin() is called in a subclass.
  *
- * The current createInstance() method passes more arguments
- * to the job and viewstep constructors than we want; chasing
- * that change means modifying each Calamares module. This class
- * implements a version of createInstance() with fewer arguments
- * and overloads registerPlugin() to use that.
  */
-class CalamaresPluginFactory : public KPluginFactory
+class CalamaresPluginFactory : public QObject
 {
     Q_OBJECT
 public:
-    explicit CalamaresPluginFactory()
-        : KPluginFactory()
-    {
-    }
+    explicit CalamaresPluginFactory() {}
     ~CalamaresPluginFactory() override;
 
-    /** @brief Create an object from the factory.
-     *
-     * Ignores all the @p args since they are not used. Calls
-     * Calamares constructors for the Jobs and ViewSteps.
-     */
-    template < class impl, class ParentType >
-    static QObject* createInstance( QWidget* parentWidget, QObject* parent, const QVariantList& args )
+    typedef QObject* ( *CreateInstanceFunction )( QObject* );
+
+    template < class T >
+    T* create( QObject* parent = nullptr )
     {
-        Q_UNUSED( parentWidget )
-        Q_UNUSED( args )
-        ParentType* p = nullptr;
-        if ( parent )
+        auto* op = fn ? fn( parent ) : nullptr;
+        if ( !op )
         {
-            p = qobject_cast< ParentType* >( parent );
-            Q_ASSERT( p );
+            return nullptr;
         }
-        return new impl( p );
+        T* tp = qobject_cast< T* >( op );
+        if ( !tp )
+        {
+            delete op;
+        }
+        return tp;
     }
 
-    /** @brief register a plugin
-     *
-     * The Calamares version doesn't accept keywords, and uses
-     * the Calamares createInstance() version which ignores
-     * the QVariantList of arguments.
-     */
-    template < class T >
-    void registerPlugin()
-    {
-        KPluginFactory::registerPlugin< T >( QString(), &createInstance< T, QObject > );
-    }
+protected:
+    CreateInstanceFunction fn = nullptr;
 };
 
 /** @brief declare a Calamares Plugin Factory
  *
- * This would be defined as K_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY,
- * except that does not actually use the base factory class that is
- * passed in.
+ * There should be one declaration -- generally alongside the
+ * class definition for the Job or ViewStep that the plugin is
+ * going to provide, in the header -- and one definition -- in
+ * the corresponding implementation.
  */
 #define CALAMARES_PLUGIN_FACTORY_DECLARATION( name ) \
     class name : public CalamaresPluginFactory \
     { \
         Q_OBJECT \
-        Q_INTERFACES( KPluginFactory ) \
+        Q_INTERFACES( CalamaresPluginFactory ) \
         Q_PLUGIN_METADATA( IID CalamaresPluginFactory_iid ) \
     public: \
         explicit name(); \
         ~name() override; \
+        template < class T > \
+        static QObject* createInstance( QObject* parent ) \
+        { \
+            return new T( parent ); \
+        } \
+        template < class T > \
+        void registerPlugin() \
+        { \
+            fn = createInstance< T >; \
+        } \
     };
+
+/** @brief Define a Calamares Plugin Factory
+ *
+ * This should be done exactly once, generally in the translation
+ * unit containing the definitions for the main class of the plugin,
+ * either the Job or the ViewStep definitions.
+ *
+ * The @p name must match the name used in the declaration, while
+ * @p pluginRegistrations should be a single call to `registerPlugin<T>()`
+ * where `T` is the type (subclass of Job or ViewStep) defined by the
+ * plugin, eg.
+ *
+ * ```
+ * CALAMARES_PLUGIN_FACTORY_DEFINITION( MyPlugin, registerPlugin<MyPluginJob>() )
+ * ```
+ *
+ * Leaving out the `()` will lead to generally-weird compiler warnings.
+ */
 #define CALAMARES_PLUGIN_FACTORY_DEFINITION( name, pluginRegistrations ) \
-    K_PLUGIN_FACTORY_DEFINITION_WITH_BASEFACTORY( name, CalamaresPluginFactory, pluginRegistrations )
+    name::name() \
+        : CalamaresPluginFactory() \
+    { \
+        pluginRegistrations; \
+    } \
+    name::~name() {}
+
+Q_DECLARE_INTERFACE( CalamaresPluginFactory, CalamaresPluginFactory_iid )
 
 #endif

src/libcalamares/utils/String.cpp

@@ -19,7 +19,9 @@
 
 #include <QStringList>
 
-namespace CalamaresUtils
+namespace Calamares
+{
+namespace String
 {
 QString
 removeDiacritics( const QString& string )
@@ -124,7 +126,7 @@ obscure( const QString& string )
 
 
 QString
-truncateMultiLine( const QString& string, CalamaresUtils::LinesStartEnd lines, CalamaresUtils::CharCount chars )
+truncateMultiLine( const QString& string, LinesStartEnd lines, CharCount chars )
 {
     const char NEWLINE = '\n';
     const int maxLines = lines.atStart + lines.atEnd;
@@ -246,4 +248,5 @@ removeTrailing( QString& string, QChar c )
     string.remove( lastIndex, string.length() );
 }
 
-}  // namespace CalamaresUtils
+}  // namespace String
+}  // namespace Calamares

src/libcalamares/utils/String.h

@@ -42,10 +42,15 @@ constexpr static const auto SplitKeepEmptyParts =
 #endif
     ;
 
+namespace Calamares
+{
 /**
- * @brief The CalamaresUtils namespace contains utility functions.
+ * @brief The Calamares::String namespace
+ *
+ * This namespace contains functions related to string-handling,
+ * string-expansion, etc.
  */
-namespace CalamaresUtils
+namespace String
 {
 /**
  * @brief removeDiacritics replaces letters with diacritics and ligatures with
@@ -113,6 +118,7 @@ DLLEXPORT void removeLeading( QString& string, QChar c );
  */
 DLLEXPORT void removeTrailing( QString& string, QChar c );
 
-}  // namespace CalamaresUtils
+}  // namespace String
+}  // namespace Calamares
 
 #endif

src/libcalamares/utils/StringExpander.cpp

@@ -0,0 +1,89 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2022 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ *
+ */
+
+#include "StringExpander.h"
+#include "Logger.h"
+
+namespace Calamares
+{
+namespace String
+{
+
+struct DictionaryExpander::Private
+{
+    QHash< QString, QString > dictionary;
+    QStringList missing;
+};
+
+DictionaryExpander::DictionaryExpander()
+    : KWordMacroExpander( '$' )
+    , d( std::make_unique< Private >() )
+{
+}
+
+DictionaryExpander::DictionaryExpander( Calamares::String::DictionaryExpander&& other )
+    : KWordMacroExpander( other.escapeChar() )
+    , d( std::move( other.d ) )
+{
+}
+
+
+DictionaryExpander::~DictionaryExpander() {}
+
+
+void
+DictionaryExpander::insert( const QString& key, const QString& value )
+{
+    d->dictionary.insert( key, value );
+}
+
+void
+DictionaryExpander::clearErrors()
+{
+    d->missing.clear();
+}
+
+bool
+DictionaryExpander::hasErrors() const
+{
+    return !d->missing.isEmpty();
+}
+
+QStringList
+DictionaryExpander::errorNames() const
+{
+    return d->missing;
+}
+
+QString
+DictionaryExpander::expand( QString s )
+{
+    clearErrors();
+    expandMacros( s );
+    return s;
+}
+
+bool
+DictionaryExpander::expandMacro( const QString& str, QStringList& ret )
+{
+    if ( d->dictionary.contains( str ) )
+    {
+        ret << d->dictionary[ str ];
+        return true;
+    }
+    else
+    {
+        d->missing << str;
+        return false;
+    }
+}
+
+}  // namespace String
+}  // namespace Calamares

src/libcalamares/utils/StringExpander.h

@@ -0,0 +1,69 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2022 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ *
+ */
+
+#ifndef UTILS_STRINGEXPANDER_H
+#define UTILS_STRINGEXPANDER_H
+
+#include "DllMacro.h"
+
+#include <KMacroExpander>
+
+#include <QString>
+#include <QStringList>
+
+#include <memory>
+
+namespace Calamares
+{
+namespace String
+{
+
+/** @brief Expand variables in a string against a dictionary.
+ *
+ * This class provides a convenience API for building up a dictionary
+ * and using it to expand strings. Use the `expand()` method to
+ * do standard word-based expansion with `$` as macro-symbol.
+ *
+ * Unlike straight-up `KMacroExpander::expandMacros()`, this
+ * provides an API to find out which variables were missing
+ * from the dictionary during expansion. Use `hasErrors()` and
+ * `errorNames()` to find out which variables those were.
+ *
+ * Call `clearErrors()` to reset the stored errors. Calling
+ * `expand()` implicitly clears the errors before starting
+ * a new expansion, as well.
+ */
+class DictionaryExpander : public KWordMacroExpander
+{
+public:
+    DictionaryExpander();
+    DictionaryExpander( DictionaryExpander&& );
+    virtual ~DictionaryExpander() override;
+
+    void insert( const QString& key, const QString& value );
+
+    void clearErrors();
+    bool hasErrors() const;
+    QStringList errorNames() const;
+
+    QString expand( QString s );
+
+protected:
+    virtual bool expandMacro( const QString& str, QStringList& ret ) override;
+
+private:
+    struct Private;
+    std::unique_ptr< Private > d;
+};
+
+}  // namespace String
+}  // namespace Calamares
+
+#endif

src/libcalamares/utils/Tests.cpp

@@ -10,11 +10,13 @@
  */
 
 #include "CalamaresUtilsSystem.h"
+#include "CommandList.h"
 #include "Entropy.h"
 #include "Logger.h"
 #include "RAII.h"
 #include "Runner.h"
 #include "String.h"
+#include "StringExpander.h"
 #include "Traits.h"
 #include "UMask.h"
 #include "Variant.h"
@@ -45,7 +47,10 @@ private Q_SLOTS:
     void testLoadSaveYaml();  // Just settings.conf
     void testLoadSaveYamlExtended();  // Do a find() in the src dir
 
+    /** @section Test running commands and command-expansion. */
     void testCommands();
+    void testCommandExpansion_data();
+    void testCommandExpansion();  // See also shellprocess tests
 
     /** @section Test that all the UMask objects work correctly. */
     void testUmask();
@@ -75,6 +80,10 @@ private Q_SLOTS:
     void testStringRemoveTrailing_data();
     void testStringRemoveTrailing();
 
+    /** @section Test String expansion. */
+    void testStringMacroExpander_data();
+    void testStringMacroExpander();  // The KF5::CoreAddons bits
+
     /** @section Test Runner directory-manipulation. */
     void testRunnerDirs();
     void testCalculateWorkingDirectory();
@@ -94,6 +103,16 @@ LibCalamaresTests::~LibCalamaresTests() {}
 void
 LibCalamaresTests::initTestCase()
 {
+    Calamares::GlobalStorage* gs
+        = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+
+    if ( !gs )
+    {
+        cDebug() << "Creating new JobQueue";
+        (void)new Calamares::JobQueue();
+        gs = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+    }
+    QVERIFY( gs );
 }
 
 void
@@ -251,6 +270,34 @@ LibCalamaresTests::testCommands()
     QVERIFY( r.getOutput().contains( tfn.fileName() ) );
 }
 
+void
+LibCalamaresTests::testCommandExpansion_data()
+{
+    QTest::addColumn< QString >( "command" );
+    QTest::addColumn< QString >( "expected" );
+
+    QTest::newRow( "empty" ) << QString() << QString();
+    QTest::newRow( "ls   " ) << QStringLiteral( "ls" ) << QStringLiteral( "ls" );
+    QTest::newRow( "user " ) << QStringLiteral( "chmod $USER" ) << QStringLiteral( "chmod alice" );
+}
+
+void
+LibCalamaresTests::testCommandExpansion()
+{
+    Calamares::GlobalStorage* gs
+        = Calamares::JobQueue::instance() ? Calamares::JobQueue::instance()->globalStorage() : nullptr;
+    QVERIFY( gs );
+    gs->insert( QStringLiteral( "username" ), QStringLiteral( "alice" ) );
+
+    QFETCH( QString, command );
+    QFETCH( QString, expected );
+    CalamaresUtils::CommandLine c( command, std::chrono::seconds( 0 ) );
+    CalamaresUtils::CommandLine e = c.expand();
+
+    QCOMPARE( c.command(), command );
+    QCOMPARE( e.command(), expected );
+}
+
 void
 LibCalamaresTests::testUmask()
 {
@@ -554,7 +601,7 @@ LibCalamaresTests::testStringTruncation()
 {
     Logger::setupLogLevel( Logger::LOGDEBUG );
 
-    using namespace CalamaresUtils;
+    using namespace Calamares::String;
 
     const QString longString( R"(---
 --- src/libcalamares/utils/String.h
@@ -635,7 +682,7 @@ LibCalamaresTests::testStringTruncationShorter()
 {
     Logger::setupLogLevel( Logger::LOGDEBUG );
 
-    using namespace CalamaresUtils;
+    using namespace Calamares::String;
 
     const QString longString( R"(Some strange string artifacts appeared, leading to `{1?}` being
 displayed in various user-facing messages. These have been removed
@@ -730,7 +777,7 @@ LibCalamaresTests::testStringTruncationDegenerate()
 {
     Logger::setupLogLevel( Logger::LOGDEBUG );
 
-    using namespace CalamaresUtils;
+    using namespace Calamares::String;
 
     // This is quite long, 1 line only, with no newlines
     const QString longString( "The portscout new distfile checker has detected that one or more of your "
@@ -783,7 +830,7 @@ LibCalamaresTests::testStringRemoveLeading()
     QFETCH( QString, result );
 
     const QString initial = string;
-    CalamaresUtils::removeLeading( string, c );
+    Calamares::String::removeLeading( string, c );
     QCOMPARE( string, result );
 }
 
@@ -813,10 +860,64 @@ LibCalamaresTests::testStringRemoveTrailing()
     QFETCH( QString, result );
 
     const QString initial = string;
-    CalamaresUtils::removeTrailing( string, c );
+    Calamares::String::removeTrailing( string, c );
     QCOMPARE( string, result );
 }
 
+void
+LibCalamaresTests::testStringMacroExpander_data()
+{
+    QTest::addColumn< QString >( "source" );
+    QTest::addColumn< QString >( "result" );
+    QTest::addColumn< QStringList >( "errors" );
+
+    QTest::newRow( "empty   " ) << QString() << QString() << QStringList {};
+    QTest::newRow( "constant" ) << QStringLiteral( "bunnies!" ) << QStringLiteral( "bunnies!" ) << QStringList {};
+    QTest::newRow( "escaped " ) << QStringLiteral( "$$bun" ) << QStringLiteral( "$bun" )
+                                << QStringList {};  // Double $$ is an escaped $
+    QTest::newRow( "whole   " ) << QStringLiteral( "${ROOT}" ) << QStringLiteral( "wortel" ) << QStringList {};
+    QTest::newRow( "unbraced" ) << QStringLiteral( "$ROOT" ) << QStringLiteral( "wortel" )
+                                << QStringList {};  // Does not need {}
+    QTest::newRow( "bad-var1" ) << QStringLiteral( "${ROOF}" ) << QStringLiteral( "${ROOF}" )
+                                << QStringList { QStringLiteral( "ROOF" ) };  // Not replaced
+    QTest::newRow( "twice   " ) << QStringLiteral( "${ROOT}x${ROOT}" ) << QStringLiteral( "wortelxwortel" )
+                                << QStringList {};
+    QTest::newRow( "bad-var2" ) << QStringLiteral( "${ROOT}x${ROPE}" ) << QStringLiteral( "wortelx${ROPE}" )
+                                << QStringList { QStringLiteral( "ROPE" ) };  // Not replaced
+    // This is a borked string with a "nested" variable. The variable-name-
+    // scanner goes from ${ to the next } and tries to match that.
+    QTest::newRow( "confuse1" ) << QStringLiteral( "${RO${ROOT}" ) << QStringLiteral( "${ROwortel" )
+                                << QStringList { "RO${ROOT" };
+    // This one doesn't have a { for the first name to match with
+    QTest::newRow( "confuse2" ) << QStringLiteral( "$RO${ROOT}" ) << QStringLiteral( "$ROwortel" )
+                                << QStringList { "RO" };
+    // Here we see it just doesn't nest
+    QTest::newRow( "confuse3" ) << QStringLiteral( "${RO${ROOT}}" ) << QStringLiteral( "${ROwortel}" )
+                                << QStringList { "RO${ROOT" };
+}
+
+void
+LibCalamaresTests::testStringMacroExpander()
+{
+    QHash< QString, QString > dict;
+    dict.insert( QStringLiteral( "ROOT" ), QStringLiteral( "wortel" ) );
+
+    Calamares::String::DictionaryExpander d;
+    d.insert( QStringLiteral( "ROOT" ), QStringLiteral( "wortel" ) );
+
+    QFETCH( QString, source );
+    QFETCH( QString, result );
+    QFETCH( QStringList, errors );
+
+    QString km_expanded = KMacroExpander::expandMacros( source, dict, '$' );
+    QCOMPARE( km_expanded, result );
+
+    QString de_expanded = d.expand( source );
+    QCOMPARE( de_expanded, result );
+    QCOMPARE( d.errorNames(), errors );
+    QCOMPARE( d.hasErrors(), !errors.isEmpty() );
+}
+
 static QString
 dirname( const QTemporaryDir& d )
 {

src/libcalamares/utils/Units.h

@@ -17,6 +17,8 @@
 
 namespace CalamaresUtils
 {
+/// @brief Type for expressing units
+using intunit_t = quint64;
 
 namespace Units
 {
@@ -137,12 +139,19 @@ BytesToMiB( qint64 b )
     return int( b / 1024 / 1024 );
 }
 
+// TODO: deprecate signed version
 constexpr int
 BytesToGiB( qint64 b )
 {
     return int( b / 1024 / 1024 / 1024 );
 }
 
+constexpr intunit_t
+BytesToGiB( intunit_t b )
+{
+    return b / 1024 / 1024 / 1024;
+}
+
 constexpr qint64
 alignBytesToBlockSize( qint64 bytes, qint64 blocksize )
 {

src/libcalamaresui/Branding.cpp

@@ -24,6 +24,7 @@
 #include <QDir>
 #include <QFile>
 #include <QIcon>
+#include <QMetaEnum>
 #include <QPixmap>
 #include <QVariantMap>
 
@@ -85,14 +86,6 @@ const QStringList Branding::s_imageEntryStrings =
     "productWelcome"
 };
 
-const QStringList Branding::s_styleEntryStrings =
-{
-    "sidebarBackground",
-    "sidebarText",
-    "sidebarTextSelect",
-    "sidebarTextHighlight"
-};
-
 const QStringList Branding::s_uploadServerStrings =
 {
     "type",
@@ -102,6 +95,36 @@ const QStringList Branding::s_uploadServerStrings =
 // clang-format on
 // *INDENT-ON*
 
+/** @brief Check that all the entries in the @p style map make sense
+ *
+ * This will catch typo's in key names.
+ */
+static bool
+validateStyleEntries( const QMap< QString, QString >& style )
+{
+    using SE = Branding::StyleEntry;
+
+    Logger::Once o;
+    bool valid = true;
+
+    const auto meta = QMetaEnum::fromType< SE >();
+    QSet< QString > validNames;
+    for ( SE i : { SE::SidebarBackground, SE::SidebarBackgroundCurrent, SE::SidebarText, SE::SidebarTextCurrent } )
+    {
+        validNames.insert( meta.valueToKey( i ) );
+    }
+
+    for ( const auto& k : style.keys() )
+    {
+        if ( !validNames.contains( k ) )
+        {
+            cWarning() << o << "Unknown branding *style* entry" << k;
+            valid = false;
+        }
+    }
+
+    return valid;
+}
 
 const NamedEnumTable< Branding::WindowDimensionUnit >&
 Branding::WindowDimension::suffixes()
@@ -296,6 +319,7 @@ Branding::Branding( const QString& brandingFilePath, QObject* parent )
     {
         cDebug() << "Loaded branding component" << m_componentName;
     }
+    validateStyleEntries( m_style );
 }
 
 
@@ -317,7 +341,8 @@ Branding::string( Branding::StringEntry stringEntry ) const
 QString
 Branding::styleString( Branding::StyleEntry styleEntry ) const
 {
-    return m_style.value( s_styleEntryStrings.value( styleEntry ) );
+    const auto meta = QMetaEnum::fromType< Branding::StyleEntry >();
+    return m_style.value( meta.valueToKey( styleEntry ) );
 }
 
 

src/libcalamaresui/Branding.h

@@ -28,7 +28,7 @@
 namespace YAML
 {
 class Node;
-}
+}  // namespace YAML
 
 namespace Calamares
 {
@@ -72,14 +72,18 @@ public:
     };
     Q_ENUM( ImageEntry )
 
+    /** @brief Names of style entries, for use in code
+     *
+     * These names are mapped to names in the branding.desc file through
+     * an internal table s_styleEntryStrings, which defines which names
+     * in `branding.desc` key *style* are used for which entry.
+     */
     enum StyleEntry : short
     {
         SidebarBackground,
         SidebarText,
-        SidebarTextSelect,
-        SidebarTextSelected = SidebarTextSelect,  // TODO:3.3:Remove SidebarTextSelect
-        SidebarTextHighlight,
-        SidebarBackgroundSelected = SidebarTextHighlight  // TODO:3.3:Remove SidebarTextHighlight
+        SidebarTextCurrent,
+        SidebarBackgroundCurrent,
     };
     Q_ENUM( StyleEntry )
 
@@ -258,6 +262,12 @@ public slots:
     QString shortProductName() const { return string( ShortProductName ); }
     QString shortVersionedName() const { return string( ShortVersionedName ); }
 
+    /** @brief Map an enum-value to the entry from the *style* key.
+     *
+     * e.g. StyleEntry::SidebarTextCurrent maps to the corresponding
+     * *style* entry, which is (confusingly) named "sidebarTextSelect"
+     * in the branding file.
+     */
     QString styleString( StyleEntry styleEntry ) const;
     QString imagePath( ImageEntry imageEntry ) const;
 
@@ -269,7 +279,6 @@ private:
 
     static const QStringList s_stringEntryStrings;
     static const QStringList s_imageEntryStrings;
-    static const QStringList s_styleEntryStrings;
     static const QStringList s_uploadServerStrings;
 
     QString m_descriptorPath;  // Path to descriptor (e.g. "/etc/calamares/default/branding.desc")

src/libcalamaresui/CMakeLists.txt

@@ -8,24 +8,21 @@
 # view modules, view steps, widgets, and branding.
 
 # The UI libs use the non-UI library
-include_directories( ${CMAKE_SOURCE_DIR}/src/libcalamares ${CMAKE_BINARY_DIR}/src/libcalamares ${CMAKE_SOURCE_DIR} )
+include_directories(${CMAKE_SOURCE_DIR}/src/libcalamares ${CMAKE_BINARY_DIR}/src/libcalamares ${CMAKE_SOURCE_DIR})
 
-set( calamaresui_SOURCES
+set(calamaresui_SOURCES
     modulesystem/CppJobModule.cpp
     modulesystem/ModuleFactory.cpp
     modulesystem/ModuleManager.cpp
     modulesystem/ProcessJobModule.cpp
     modulesystem/ViewModule.cpp
-
     utils/CalamaresUtilsGui.cpp
     utils/ImageRegistry.cpp
     utils/Paste.cpp
-
     viewpages/BlankViewStep.cpp
     viewpages/ExecutionViewStep.cpp
     viewpages/Slideshow.cpp
     viewpages/ViewStep.cpp
-
     widgets/ClickableLabel.cpp
     widgets/ErrorDialog.cpp
     widgets/FixedAspectRatioLabel.cpp
@@ -33,42 +30,20 @@ set( calamaresui_SOURCES
     widgets/LogWidget.cpp
     widgets/TranslationFix.cpp
     widgets/WaitingWidget.cpp
-    ${CMAKE_SOURCE_DIR}/3rdparty/waitingspinnerwidget.cpp
-
+    widgets/waitingspinnerwidget.cpp
     Branding.cpp
     ViewManager.cpp
 )
 
-# Don't warn about third-party sources
-mark_thirdparty_code(
-    ${CMAKE_SOURCE_DIR}/3rdparty/waitingspinnerwidget.cpp
-)
-
-if( WITH_PYTHON )
-    list( APPEND calamaresui_SOURCES
-        modulesystem/PythonJobModule.cpp
-    )
+if(WITH_PYTHON)
+    list(APPEND calamaresui_SOURCES modulesystem/PythonJobModule.cpp)
 endif()
 
-if( WITH_PYTHONQT )
-    list( APPEND calamaresui_SOURCES
-        modulesystem/PythonQtViewModule.cpp
-        utils/PythonQtUtils.cpp
-        viewpages/PythonQtJob.cpp
-        viewpages/PythonQtViewStep.cpp
-        viewpages/PythonQtGlobalStorageWrapper.cpp
-        viewpages/PythonQtUtilsWrapper.cpp
-    )
+if(WITH_QML)
+    list(APPEND calamaresui_SOURCES utils/Qml.cpp viewpages/QmlViewStep.cpp)
 endif()
 
-if( WITH_QML )
-    list( APPEND calamaresui_SOURCES
-        utils/Qml.cpp
-        viewpages/QmlViewStep.cpp
-    )
-endif()
-
-calamares_add_library( calamaresui
+calamares_add_library(calamaresui
     SOURCES ${calamaresui_SOURCES}
     EXPORT_MACRO UIDLLEXPORT_PRO
     LINK_LIBRARIES
@@ -79,22 +54,17 @@ calamares_add_library( calamaresui
         utils/ErrorDialog/ErrorDialog.ui
     VERSION ${CALAMARES_VERSION_SHORT}
 )
-target_link_libraries( calamaresui PRIVATE yamlcpp::yamlcpp )
-if( KF5CoreAddons_FOUND AND KF5CoreAddons_VERSION VERSION_GREATER_EQUAL 5.58 )
-    target_compile_definitions( calamaresui PRIVATE WITH_KOSRelease )
+target_link_libraries(calamaresui PRIVATE yamlcpp::yamlcpp)
+if(KF5CoreAddons_FOUND AND KF5CoreAddons_VERSION VERSION_GREATER_EQUAL 5.58)
+    target_compile_definitions(calamaresui PRIVATE WITH_KOSRelease)
+    target_link_libraries(calamaresui PRIVATE KF5::CoreAddons)
 endif()
-if( WITH_PYTHONQT )
-    # *_DIRS because we also use extensions
-    target_include_directories( calamaresui PRIVATE ${PYTHON_INCLUDE_DIRS} ${PYTHONQT_INCLUDE_DIRS} )
-    target_link_libraries( calamaresui PRIVATE ${PYTHON_LIBRARIES} ${PYTHONQT_LIBRARIES} )
-endif()
-if( WITH_QML )
-    target_link_libraries( calamaresui PUBLIC Qt5::QuickWidgets )
+if(WITH_QML)
+    target_link_libraries(calamaresui PUBLIC Qt5::QuickWidgets)
 endif()
 
 add_library(Calamares::calamaresui ALIAS calamaresui)
 
-
 ### Installation
 #
 #
@@ -103,24 +73,12 @@ add_library(Calamares::calamaresui ALIAS calamaresui)
 # where libcalamares and libcalamaresui live in different branches,
 # we're going to glom it all together in the installed headers location.
 
-install(
-    FILES
-        Branding.h
-        ViewManager.h
-    DESTINATION include/libcalamares
-)
+install(FILES Branding.h ViewManager.h DESTINATION include/libcalamares)
 
 # Install each subdir-worth of header files
-foreach( subdir modulesystem utils viewpages widgets )
-    file( GLOB subdir_headers "${subdir}/*.h" )
-    install( FILES ${subdir_headers} DESTINATION include/libcalamares/${subdir} )
+foreach(subdir modulesystem utils viewpages widgets)
+    file(GLOB subdir_headers "${subdir}/*.h")
+    install(FILES ${subdir_headers} DESTINATION include/libcalamares/${subdir})
 endforeach()
 
-calamares_add_test(
-    test_libcalamaresuipaste
-    SOURCES
-        utils/TestPaste.cpp
-        utils/Paste.cpp
-    LIBRARIES
-        calamaresui
-)
+calamares_add_test(test_libcalamaresuipaste SOURCES utils/TestPaste.cpp utils/Paste.cpp LIBRARIES calamaresui)

src/libcalamaresui/modulesystem/ModuleFactory.cpp

@@ -24,10 +24,6 @@
 #include "PythonJobModule.h"
 #endif
 
-#ifdef WITH_PYTHONQT
-#include "PythonQtViewModule.h"
-#endif
-
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
@@ -59,14 +55,6 @@ moduleFromDescriptor( const Calamares::ModuleSystem::Descriptor& moduleDescripto
         {
             m.reset( new ViewModule() );
         }
-        else if ( moduleDescriptor.interface() == Interface::PythonQt )
-        {
-#ifdef WITH_PYTHONQT
-            m.reset( new PythonQtViewModule() );
-#else
-            cError() << "PythonQt view modules are not supported in this version of Calamares.";
-#endif
-        }
         else
         {
             cError() << "Bad interface"

src/libcalamaresui/modulesystem/ModuleManager.cpp

@@ -214,7 +214,7 @@ ModuleManager::loadModules()
                 continue;
             }
 
-            ModuleSystem::Descriptor descriptor
+            const ModuleSystem::Descriptor descriptor
                 = m_availableDescriptorsByModuleName.value( instanceKey.module(), ModuleSystem::Descriptor() );
             if ( !descriptor.isValid() )
             {
@@ -349,7 +349,18 @@ ModuleManager::checkRequirements()
     connect( rq,
              &RequirementsChecker::done,
              this,
-             [ = ]() { this->requirementsComplete( m_requirementsModel->satisfiedMandatory() ); } );
+             [ = ]()
+             {
+                 if ( m_requirementsModel->satisfiedMandatory() )
+                 {
+                     /* we're done */ this->requirementsComplete( true );
+                 }
+                 else
+                 {
+                     this->requirementsComplete( false );
+                     QTimer::singleShot( std::chrono::seconds( 5 ), this, &ModuleManager::checkRequirements );
+                 }
+             } );
 
     QTimer::singleShot( 0, rq, &RequirementsChecker::run );
 }

src/libcalamaresui/modulesystem/PythonQtViewModule.cpp

@@ -1,184 +0,0 @@
-/* === This file is part of Calamares - <https://calamares.io> ===
- *
- *   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
- *   SPDX-FileCopyrightText: 2018 Adriaan de Groot <groot@kde.org>
- *   SPDX-FileCopyrightText: 2018 Raul Rodrigo Segura <raurodse@gmail.com>
- *   SPDX-License-Identifier: GPL-3.0-or-later
- *
- *   Calamares is Free Software: see the License-Identifier above.
- *
- */
-
-#include "PythonQtViewModule.h"
-
-#include "CalamaresConfig.h"
-#include "GlobalStorage.h"
-#include "JobQueue.h"
-#include "ViewManager.h"
-#include "utils/Logger.h"
-#include "viewpages/PythonQtGlobalStorageWrapper.h"
-#include "viewpages/PythonQtUtilsWrapper.h"
-#include "viewpages/PythonQtViewStep.h"
-#include "viewpages/ViewStep.h"
-
-#include <PythonQt.h>
-#include <PythonQt_QtAll.h>
-
-#include <QDir>
-#include <QPointer>
-
-
-static QPointer< GlobalStorage > s_gs = nullptr;
-static QPointer< Utils > s_utils = nullptr;
-
-namespace Calamares
-{
-
-Module::Type
-PythonQtViewModule::type() const
-{
-    return Module::Type::View;
-}
-
-
-Module::Interface
-PythonQtViewModule::interface() const
-{
-    return Module::Interface::PythonQt;
-}
-
-
-void
-PythonQtViewModule::loadSelf()
-{
-    if ( !m_scriptFileName.isEmpty() )
-    {
-        if ( PythonQt::self() == nullptr )
-        {
-            if ( Py_IsInitialized() )
-                PythonQt::init( PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut
-                                | PythonQt::PythonAlreadyInitialized );
-            else
-            {
-                PythonQt::init();
-            }
-
-            PythonQt_QtAll::init();
-            cDebug() << "Initializing PythonQt bindings."
-                     << "This should only happen once.";
-
-            //TODO: register classes here into the PythonQt environment, like this:
-            //PythonQt::self()->registerClass( &PythonQtViewStep::staticMetaObject,
-            //                                 "calamares" );
-
-            // We only do the following to force PythonQt to create a submodule
-            // "calamares" for us to put our static objects in
-            PythonQt::self()->registerClass( &::GlobalStorage::staticMetaObject, "calamares" );
-
-            // Get a PythonQtObjectPtr to the PythonQt.calamares submodule
-            PythonQtObjectPtr pqtm = PythonQt::priv()->pythonQtModule();
-            PythonQtObjectPtr cala = PythonQt::self()->lookupObject( pqtm, "calamares" );
-
-            // Prepare GlobalStorage object, in module PythonQt.calamares
-            if ( !s_gs )
-            {
-                s_gs = new ::GlobalStorage( Calamares::JobQueue::instance()->globalStorage() );
-            }
-            cala.addObject( "global_storage", s_gs );
-
-            // Prepare Utils object, in module PythonQt.calamares
-            if ( !s_utils )
-            {
-                s_utils = new ::Utils( Calamares::JobQueue::instance()->globalStorage() );
-            }
-            cala.addObject( "utils", s_utils );
-
-            // Append configuration object, in module PythonQt.calamares
-            cala.addVariable( "configuration", m_configurationMap );
-
-            // Basic stdout/stderr handling
-            QObject::connect( PythonQt::self(),
-                              &PythonQt::pythonStdOut,
-                              []( const QString& message ) { cDebug() << "PythonQt OUT>" << message; } );
-            QObject::connect( PythonQt::self(),
-                              &PythonQt::pythonStdErr,
-                              []( const QString& message ) { cDebug() << "PythonQt ERR>" << message; } );
-        }
-
-        QDir workingDir( m_workingPath );
-        if ( !workingDir.exists() )
-        {
-            cDebug() << "Invalid working directory" << m_workingPath << "for module" << name();
-            return;
-        }
-
-        QString fullPath = workingDir.absoluteFilePath( m_scriptFileName );
-        QFileInfo scriptFileInfo( fullPath );
-        if ( !scriptFileInfo.isReadable() )
-        {
-            cDebug() << "Invalid main script file path" << fullPath << "for module" << name();
-            return;
-        }
-
-        // Construct empty Python module with the given name
-        PythonQtObjectPtr cxt = PythonQt::self()->createModuleFromScript( name() );
-        if ( cxt.isNull() )
-        {
-            cDebug() << "Cannot load PythonQt context from file" << fullPath << "for module" << name();
-            return;
-        }
-
-        static const QLatin1String calamares_module_annotation(
-            "_calamares_module_typename = ''\n"
-            "def calamares_module(viewmodule_type):\n"
-            "    global _calamares_module_typename\n"
-            "    _calamares_module_typename = viewmodule_type.__name__\n"
-            "    return viewmodule_type\n" );
-
-        // Load in the decorator
-        PythonQt::self()->evalScript( cxt, calamares_module_annotation );
-
-        // Load the module
-        PythonQt::self()->evalFile( cxt, fullPath );
-
-        m_viewStep = new PythonQtViewStep( cxt );
-
-        cDebug() << "PythonQtViewModule loading self for instance" << instanceKey() << "\nPythonQtViewModule at address"
-                 << this << "\nViewStep at address" << m_viewStep;
-
-        m_viewStep->setModuleInstanceKey( instanceKey() );
-        m_viewStep->setConfigurationMap( m_configurationMap );
-        ViewManager::instance()->addViewStep( m_viewStep );
-        m_loaded = true;
-        cDebug() << "PythonQtViewModule" << instanceKey() << "loading complete.";
-    }
-}
-
-
-JobList
-PythonQtViewModule::jobs() const
-{
-    return m_viewStep->jobs();
-}
-
-
-void
-PythonQtViewModule::initFrom( const QVariantMap& moduleDescriptor )
-{
-    QDir directory( location() );
-    m_workingPath = directory.absolutePath();
-
-    if ( !moduleDescriptor.value( "script" ).toString().isEmpty() )
-    {
-        m_scriptFileName = moduleDescriptor.value( "script" ).toString();
-    }
-}
-
-PythonQtViewModule::PythonQtViewModule()
-    : Module()
-{
-}
-
-PythonQtViewModule::~PythonQtViewModule() {}
-
-}  // namespace Calamares

src/libcalamaresui/modulesystem/PythonQtViewModule.h

@@ -1,50 +0,0 @@
-/* === This file is part of Calamares - <https://calamares.io> ===
- *
- *   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
- *   SPDX-License-Identifier: GPL-3.0-or-later
- *
- *   Calamares is Free Software: see the License-Identifier above.
- *
- */
-
-#ifndef CALAMARES_PYTHONQTVIEWMODULE_H
-#define CALAMARES_PYTHONQTVIEWMODULE_H
-
-#include "DllMacro.h"
-#include "Module.h"
-
-namespace Calamares
-{
-
-class ViewStep;
-
-class UIDLLEXPORT PythonQtViewModule : public Module
-{
-public:
-    Type type() const override;
-    Interface interface() const override;
-
-    void loadSelf() override;
-    JobList jobs() const override;
-
-protected:
-    void initFrom( const QVariantMap& moduleDescriptor ) override;
-
-private:
-    explicit PythonQtViewModule();
-    virtual ~PythonQtViewModule();
-
-    ViewStep* m_viewStep = nullptr;
-
-    QString m_scriptFileName;
-    QString m_workingPath;
-
-    friend Module* Calamares::moduleFromDescriptor( const ModuleSystem::Descriptor& moduleDescriptor,
-                                                    const QString& instanceId,
-                                                    const QString& configFileName,
-                                                    const QString& moduleDirectory );
-};
-
-}  // namespace Calamares
-
-#endif  // CALAMARES_PYTHONQTVIEWMODULE_H

src/libcalamaresui/utils/CalamaresUtilsGui.cpp

@@ -128,62 +128,12 @@ defaultPixmap( ImageType type, ImageMode mode, const QSize& size )
 }
 
 
-QPixmap
-createRoundedImage( const QPixmap& pixmap, const QSize& size, float frameWidthPct )
-{
-    int height;
-    int width;
-
-    if ( !size.isEmpty() )
-    {
-        height = size.height();
-        width = size.width();
-    }
-    else
-    {
-        height = pixmap.height();
-        width = pixmap.width();
-    }
-
-    if ( !height || !width )
-    {
-        return QPixmap();
-    }
-
-    QPixmap scaledAvatar = pixmap.scaled( width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
-    if ( frameWidthPct == 0.00f )
-    {
-        return scaledAvatar;
-    }
-
-    QPixmap frame( width, height );
-    frame.fill( Qt::transparent );
-
-    QPainter painter( &frame );
-    painter.setRenderHint( QPainter::Antialiasing );
-
-    QRect outerRect( 0, 0, width, height );
-    QBrush brush( scaledAvatar );
-    QPen pen;
-    pen.setColor( Qt::transparent );
-    pen.setJoinStyle( Qt::RoundJoin );
-
-    painter.setBrush( brush );
-    painter.setPen( pen );
-    painter.drawRoundedRect(
-        outerRect, qreal( frameWidthPct ) * 100.0, qreal( frameWidthPct ) * 100.0, Qt::RelativeSize );
-
-    return frame;
-}
-
-
 void
 unmarginLayout( QLayout* layout )
 {
     if ( layout )
     {
         layout->setContentsMargins( 0, 0, 0, 0 );
-        layout->setMargin( 0 );
         layout->setSpacing( 0 );
 
         for ( int i = 0; i < layout->count(); i++ )
@@ -224,15 +174,6 @@ defaultFontHeight()
 }
 
 
-QFont
-defaultFont()
-{
-    QFont f;
-    f.setPointSize( defaultFontSize() );
-    return f;
-}
-
-
 QFont
 largeFont()
 {
@@ -257,24 +198,4 @@ defaultIconSize()
     return QSize( w, w );
 }
 
-
-void
-clearLayout( QLayout* layout )
-{
-    while ( QLayoutItem* item = layout->takeAt( 0 ) )
-    {
-        if ( QWidget* widget = item->widget() )
-        {
-            widget->deleteLater();
-        }
-
-        if ( QLayout* childLayout = item->layout() )
-        {
-            clearLayout( childLayout );
-        }
-
-        delete item;
-    }
-}
-
 }  // namespace CalamaresUtils

src/libcalamaresui/utils/CalamaresUtilsGui.h

@@ -63,7 +63,6 @@ enum ImageMode
     CoverInCase,
     Grid,
     DropShadow,
-    RoundedCorners
 };
 
 /**
@@ -78,35 +77,15 @@ UIDLLEXPORT QPixmap defaultPixmap( ImageType type,
                                    ImageMode mode = CalamaresUtils::Original,
                                    const QSize& size = QSize( 0, 0 ) );
 
-// TODO:3.3:This has only one consumer, move to ImageRegistry, make static
-/**
- * @brief createRoundedImage returns a rounded version of a pixmap.
- * @param avatar the input pixmap.
- * @param size the new size.
- * @param frameWidthPct the frame size, as percentage of width.
- * @return the transformed pixmap.
- * This one is currently unused.
- */
-UIDLLEXPORT QPixmap createRoundedImage( const QPixmap& avatar, const QSize& size, float frameWidthPct = 0.20f );
-
 /**
  * @brief unmarginLayout recursively walks the QLayout tree and removes all margins.
  * @param layout the layout to unmargin.
  */
 UIDLLEXPORT void unmarginLayout( QLayout* layout );
 
-// TODO:3.3:This has only one consumer, move to LicensePage, make static
-/**
- * @brief clearLayout recursively walks the QLayout tree and deletes all the child
- * widgets and layouts.
- * @param layout the layout to clear.
- */
-UIDLLEXPORT void clearLayout( QLayout* layout );
-
 UIDLLEXPORT void setDefaultFontSize( int points );
 UIDLLEXPORT int defaultFontSize();  // in points
 UIDLLEXPORT int defaultFontHeight();  // in pixels, DPI-specific
-UIDLLEXPORT QFont defaultFont();  // TODO:3.3:This has one consumer, move to BlankViewStep
 UIDLLEXPORT QFont largeFont();
 UIDLLEXPORT QSize defaultIconSize();
 

src/libcalamaresui/utils/ImageRegistry.cpp

@@ -8,6 +8,7 @@
 
 #include "ImageRegistry.h"
 
+#include <QHash>
 #include <QIcon>
 #include <QPainter>
 #include <QSvgRenderer>
@@ -89,11 +90,6 @@ ImageRegistry::pixmap( const QString& image, const QSize& size, CalamaresUtils::
 
     if ( !pixmap.isNull() )
     {
-        if ( mode == CalamaresUtils::RoundedCorners )
-        {
-            pixmap = CalamaresUtils::createRoundedImage( pixmap, size );
-        }
-
         if ( !size.isNull() && pixmap.size() != size )
         {
             if ( size.width() == 0 )

src/libcalamaresui/utils/PythonQtUtils.cpp

@@ -1,37 +0,0 @@
-/* === This file is part of Calamares - <https://calamares.io> ===
- *
- *   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
- *   SPDX-License-Identifier: GPL-3.0-or-later
- *
- *   Calamares is Free Software: see the License-Identifier above.
- *
- */
-
-#include "PythonQtUtils.h"
-
-namespace CalamaresUtils
-{
-
-QVariant
-lookupAndCall( PyObject* object,
-               const QStringList& candidateNames,
-               const QVariantList& args,
-               const QVariantMap& kwargs )
-{
-    Q_ASSERT( object );
-    Q_ASSERT( !candidateNames.isEmpty() );
-
-    for ( const QString& name : candidateNames )
-    {
-        PythonQtObjectPtr callable = PythonQt::self()->lookupCallable( object, name );
-        if ( callable )
-        {
-            return callable.call( args, kwargs );
-        }
-    }
-
-    // If we haven't found a callable with the given names, we force an error:
-    return PythonQt::self()->call( object, candidateNames.first(), args, kwargs );
-}
-
-}  // namespace CalamaresUtils

src/libcalamaresui/utils/PythonQtUtils.h

@@ -1,29 +0,0 @@
-/* === This file is part of Calamares - <https://calamares.io> ===
- *
- *   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
- *   SPDX-License-Identifier: GPL-3.0-or-later
- *
- *   Calamares is Free Software: see the License-Identifier above.
- *
- */
-
-#ifndef PYTHONQTUTILS_H
-#define PYTHONQTUTILS_H
-
-#include <PythonQt.h>
-
-#include <QVariant>
-
-
-namespace CalamaresUtils
-{
-//NOTE: when running this, it is assumed that Python is initialized and
-//      PythonQt::self() is valid.
-QVariant lookupAndCall( PyObject* object,
-                        const QStringList& candidateNames,
-                        const QVariantList& args = QVariantList(),
-                        const QVariantMap& kwargs = QVariantMap() );
-
-}  // namespace CalamaresUtils
-
-#endif  // PYTHONQTUTILS_H

src/libcalamaresui/viewpages/PythonQtGlobalStorageWrapper.cpp

@@ -1,61 +0,0 @@
-/* === This file is part of Calamares - <https://calamares.io> ===
- *
- *   SPDX-FileCopyrightText: 2016 Teo Mrnjavac <teo@kde.org>
- *   SPDX-License-Identifier: GPL-3.0-or-later
- *
- *   Calamares is Free Software: see the License-Identifier above.
- *
- */
-
-#include "PythonQtGlobalStorageWrapper.h"
-
-#include "GlobalStorage.h"
-
-
-GlobalStorage::GlobalStorage( Calamares::GlobalStorage* gs )
-    : QObject( gs )
-    , m_gs( gs )
-{
-}
-
-
-bool
-GlobalStorage::contains( const QString& key ) const
-{
-    return m_gs->contains( key );
-}
-
-
-int
-GlobalStorage::count() const
-{
-    return m_gs->count();
-}
-
-
-void
-GlobalStorage::insert( const QString& key, const QVariant& value )
-{
-    m_gs->insert( key, value );
-}
-
-
-QStringList
-GlobalStorage::keys() const
-{
-    return m_gs->keys();
-}
-
-
-int
-GlobalStorage::remove( const QString& key )
-{
-    return m_gs->remove( key );
-}
-
-
-QVariant
-GlobalStorage::value( const QString& key ) const
-{
-    return m_gs->value( key );
-}