feat: ask which lock screen to use on hyprland and niri

src/agent/lockpreview.cpp

@@ -0,0 +1,647 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "lockpreview.h"
+
+#include <KLocalizedString>
+
+#include <QDateTime>
+#include <QDir>
+#include <QElapsedTimer>
+#include <QFile>
+#include <QFileInfo>
+#include <QHash>
+#include <QProcess>
+#include <QRegularExpression>
+#include <QPointF>
+#include <QStandardPaths>
+#include <QTime>
+#include <QVariantMap>
+
+#include <algorithm>
+#include <pwd.h>
+#include <unistd.h>
+
+namespace
+{
+QString readFile(const QString &path)
+{
+    QFile f(path);
+    return f.open(QIODevice::ReadOnly | QIODevice::Text) ? QString::fromUtf8(f.readAll()) : QString();
+}
+
+QString expandHome(const QString &path)
+{
+    return path == u"~" ? QDir::homePath() : path.startsWith(u"~/") ? QDir::homePath() + path.mid(1) : path;
+}
+
+QString configHome()
+{
+    return QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
+}
+
+// The first file of name under the user's and then the system's config
+// directories, as hyprlock and swaylock look for theirs.
+QString findConfig(const QString &name)
+{
+    QStringList dirs{configHome()};
+    dirs += QStandardPaths::standardLocations(QStandardPaths::GenericConfigLocation);
+    for (const QString &dir : std::as_const(dirs)) {
+        if (QFileInfo::exists(dir + u'/' + name)) {
+            return dir + u'/' + name;
+        }
+    }
+    return {};
+}
+
+bool truthy(const QString &value)
+{
+    return value == u"1" || value.compare(u"true", Qt::CaseInsensitive) == 0 || value.compare(u"yes", Qt::CaseInsensitive) == 0
+        || value.compare(u"on", Qt::CaseInsensitive) == 0;
+}
+
+// ---------------------------------------------------------------------------
+// hyprlang, as far as a lock screen's config needs it
+
+struct Section {
+    QString name;
+    QHash<QString, QString> values;
+};
+
+// Sections, $variables, source = (with ~ and wildcards, relative to the
+// file), and # comments, where ## stands for a #.
+class Hyprlang
+{
+public:
+    void parse(const QString &path, int depth = 0);
+
+    QList<Section> sections;
+
+private:
+    QString expand(const QString &value) const;
+
+    QHash<QString, QString> m_vars;
+    QList<qsizetype> m_open;
+};
+
+QString stripComment(const QString &line)
+{
+    QString out;
+    for (qsizetype i = 0; i < line.size(); ++i) {
+        if (line.at(i) == u'#') {
+            if (i + 1 < line.size() && line.at(i + 1) == u'#') {
+                out += u'#';
+                ++i;
+                continue;
+            }
+            break;
+        }
+        out += line.at(i);
+    }
+    return out.trimmed();
+}
+
+void Hyprlang::parse(const QString &path, int depth)
+{
+    if (depth > 8) {
+        return;
+    }
+    const QString dir = QFileInfo(path).absolutePath();
+    const QStringList lines = readFile(path).split(u'\n');
+    for (const QString &raw : lines) {
+        const QString line = stripComment(raw);
+        if (line.isEmpty()) {
+            continue;
+        }
+        if (line == u"}") {
+            if (!m_open.isEmpty()) {
+                m_open.removeLast();
+            }
+            continue;
+        }
+        if (line.endsWith(u'{')) {
+            sections.append({line.chopped(1).trimmed(), {}});
+            m_open.append(sections.size() - 1);
+            continue;
+        }
+        const qsizetype eq = line.indexOf(u'=');
+        if (eq < 0) {
+            continue;
+        }
+        const QString key = line.left(eq).trimmed();
+        const QString value = expand(line.mid(eq + 1).trimmed());
+        if (key.startsWith(u'$')) {
+            m_vars.insert(key.mid(1), value);
+        } else if (key == u"source" && m_open.isEmpty()) {
+            const QFileInfo pattern(QDir(dir).absoluteFilePath(expandHome(value)));
+            const QStringList matches = QDir(pattern.absolutePath()).entryList({pattern.fileName()}, QDir::Files, QDir::Name);
+            for (const QString &match : matches) {
+                parse(pattern.absolutePath() + u'/' + match, depth + 1);
+            }
+        } else if (!m_open.isEmpty()) {
+            sections[m_open.last()].values.insert(key, value);
+        }
+    }
+}
+
+QString Hyprlang::expand(const QString &value) const
+{
+    if (!value.contains(u'$') || m_vars.isEmpty()) {
+        return value;
+    }
+    // Longest first, so $font does not eat the start of $fontsize.
+    QStringList names = m_vars.keys();
+    std::sort(names.begin(), names.end(), [](const QString &a, const QString &b) {
+        return a.size() > b.size();
+    });
+    QString out = value;
+    for (const QString &name : std::as_const(names)) {
+        out.replace(u'$' + name, m_vars.value(name));
+    }
+    return out;
+}
+
+// ---------------------------------------------------------------------------
+// Values
+
+// "rgba(a, b) rgba(c) 45deg": the colours and the angle.
+QVariantMap gradient(const QString &value)
+{
+    QVariantList colors;
+    double angle = 0;
+    QString token;
+    int depth = 0;
+    const auto flush = [&] {
+        const QString t = token.trimmed();
+        token.clear();
+        if (t.endsWith(u"deg")) {
+            angle = t.chopped(3).toDouble();
+        } else if (const QColor c = LockPreview::color(t); c.isValid()) {
+            colors.append(c);
+        }
+    };
+    for (const QChar ch : value) {
+        if (ch == u'(') {
+            ++depth;
+        } else if (ch == u')') {
+            --depth;
+        }
+        if (ch.isSpace() && depth == 0) {
+            flush();
+        } else {
+            token += ch;
+        }
+    }
+    flush();
+    return {{QStringLiteral("colors"), colors}, {QStringLiteral("angle"), angle}};
+}
+
+// "x, y", each in pixels or percent of the screen.
+QPointF layout(const QString &value, const QSizeF &screen)
+{
+    const QStringList parts = value.split(u',');
+    const auto one = [](const QString &part, qreal whole) {
+        const QString s = part.trimmed();
+        return s.endsWith(u'%') ? s.chopped(1).toDouble() / 100.0 * whole : s.toDouble();
+    };
+    return {one(parts.value(0), screen.width()), one(parts.value(1), screen.height())};
+}
+
+// A Pango font description ("Noto Sans Light 12") as family, weight and
+// slant.
+void font(const QString &description, QVariantMap &into)
+{
+    static const QHash<QString, int> weights{
+        {QStringLiteral("thin"), 100},       {QStringLiteral("ultra-light"), 200}, {QStringLiteral("extra-light"), 200},
+        {QStringLiteral("ultralight"), 200}, {QStringLiteral("extralight"), 200},  {QStringLiteral("light"), 300},
+        {QStringLiteral("semi-light"), 350}, {QStringLiteral("book"), 380},        {QStringLiteral("regular"), 400},
+        {QStringLiteral("normal"), 400},     {QStringLiteral("medium"), 500},      {QStringLiteral("semi-bold"), 600},
+        {QStringLiteral("semibold"), 600},   {QStringLiteral("demi-bold"), 600},   {QStringLiteral("demibold"), 600},
+        {QStringLiteral("bold"), 700},       {QStringLiteral("ultra-bold"), 800},  {QStringLiteral("extra-bold"), 800},
+        {QStringLiteral("extrabold"), 800},  {QStringLiteral("heavy"), 900},       {QStringLiteral("black"), 900},
+    };
+    QStringList words = description.section(u',', 0, 0).split(u' ', Qt::SkipEmptyParts);
+    int weight = 400;
+    bool italic = false;
+    while (words.size() > 1) {
+        const QString word = words.last().toLower();
+        bool number = false;
+        word.toDouble(&number);
+        if (number) {
+            words.removeLast();
+        } else if (word == u"italic" || word == u"oblique") {
+            italic = true;
+            words.removeLast();
+        } else if (weights.contains(word)) {
+            weight = weights.value(word);
+            words.removeLast();
+        } else {
+            break;
+        }
+    }
+    into.insert(QStringLiteral("family"), words.isEmpty() ? QStringLiteral("Sans") : words.join(u' '));
+    into.insert(QStringLiteral("weight"), weight);
+    into.insert(QStringLiteral("italic"), italic);
+}
+
+// Pango markup as Qt's StyledText: span becomes font, b and i, the rest of
+// Pango's tags go and their text stays.
+QString styled(const QString &markup)
+{
+    static const QRegularExpression tag(QStringLiteral("<(/?)([a-zA-Z]+)([^>]*)>"));
+    static const QRegularExpression attribute(QStringLiteral("([a-z_]+)\\s*=\\s*[\"']([^\"']*)[\"']"));
+    QString out;
+    QStringList closers;
+    qsizetype last = 0;
+    auto it = tag.globalMatch(markup);
+    while (it.hasNext()) {
+        const auto m = it.next();
+        out += markup.mid(last, m.capturedStart() - last);
+        last = m.capturedEnd();
+        const bool closing = !m.captured(1).isEmpty();
+        const QString name = m.captured(2).toLower();
+        if (name == u"span") {
+            if (closing) {
+                out += closers.isEmpty() ? QString() : closers.takeLast();
+                continue;
+            }
+            QString open;
+            QString close;
+            QString fontAttrs;
+            auto attrs = attribute.globalMatch(m.captured(3));
+            while (attrs.hasNext()) {
+                const auto a = attrs.next();
+                const QString key = a.captured(1);
+                QString value = a.captured(2);
+                if (key == u"foreground" || key == u"fgcolor" || key == u"color") {
+                    // Pango's #RRGGBBAA is Qt's #AARRGGBB.
+                    if (value.startsWith(u'#') && value.size() == 9) {
+                        value = u'#' + value.mid(7, 2) + value.mid(1, 6);
+                    }
+                    fontAttrs += QStringLiteral(" color=\"%1\"").arg(value);
+                } else if (key == u"font_family" || key == u"face") {
+                    fontAttrs += QStringLiteral(" face=\"%1\"").arg(value);
+                } else if ((key == u"weight" || key == u"font_weight") && (value.contains(u"bold") || value.contains(u"heavy") || value.toInt() >= 600)) {
+                    open += QStringLiteral("<b>");
+                    close.prepend(QStringLiteral("</b>"));
+                } else if ((key == u"style" || key == u"font_style") && value == u"italic") {
+                    open += QStringLiteral("<i>");
+                    close.prepend(QStringLiteral("</i>"));
+                }
+            }
+            if (!fontAttrs.isEmpty()) {
+                open.prepend(QStringLiteral("<font%1>").arg(fontAttrs));
+                close += QStringLiteral("</font>");
+            }
+            out += open;
+            closers.append(close);
+        } else if (name == u"b" || name == u"i" || name == u"u") {
+            out += m.captured(0);
+        }
+    }
+    out += markup.mid(last);
+    out.replace(u'\n', QStringLiteral("<br>"));
+    return out;
+}
+
+// What a command prints, or nothing when it takes too long.
+QString run(const QString &command, QElapsedTimer &budget)
+{
+    // A config full of slow commands (weather, music) must not keep the
+    // window from opening.
+    if (budget.elapsed() > 2000) {
+        return {};
+    }
+    QProcess process;
+    process.start(QStringLiteral("/bin/sh"), {QStringLiteral("-c"), command});
+    if (!process.waitForFinished(700)) {
+        process.kill();
+        process.waitForFinished(100);
+        return {};
+    }
+    return QString::fromUtf8(process.readAllStandardOutput());
+}
+
+// A label's text as hyprlock would show it right after locking.
+QString labelText(QString text, bool trim, QElapsedTimer &budget)
+{
+    const passwd *pw = getpwuid(getuid());
+    text.replace(QStringLiteral("$DESC"), pw ? QString::fromLocal8Bit(pw->pw_gecos) : QString());
+    text.replace(QStringLiteral("$USER"), pw ? QString::fromLocal8Bit(pw->pw_name) : QString());
+    text.replace(QStringLiteral("<br/>"), QStringLiteral("\n"));
+    const QTime now = QTime::currentTime();
+    text.replace(QStringLiteral("$TIME12"), now.toString(QStringLiteral("hh:mm AP")));
+    text.replace(QStringLiteral("$TIME"), now.toString(QStringLiteral("HH:mm")));
+    static const QRegularExpression layoutVar(QStringLiteral("\\$LAYOUT(\\[([^\\]]*)\\])?"));
+    auto layouts = layoutVar.globalMatch(text);
+    while (layouts.hasNext()) {
+        const auto m = layouts.next();
+        const QString first = m.captured(2).section(u',', 0, 0).trimmed();
+        text.replace(m.captured(0), first.isEmpty() ? QStringLiteral("en") : first);
+    }
+    // What only a lock screen that runs knows: nothing has failed yet.
+    static const QRegularExpression runtime(QStringLiteral("\\$(ATTEMPTS(\\[[^\\]]*\\])?|PAMFAIL|FPRINTFAIL|FPRINTPROMPT|FAIL)"));
+    text.remove(runtime);
+    text.replace(QStringLiteral("$PAMPROMPT"), QStringLiteral("Password:"));
+
+    if (text.startsWith(u"cmd[") && text.contains(u']')) {
+        const QString command = text.mid(text.indexOf(u']') + 1);
+        // face-unlock's own line, as it reads during a scan.
+        text = command.contains(u"face-unlock/lock-text") ? i18n("Looking for your face…").toHtmlEscaped() : run(command, budget);
+    }
+    return trim ? text.trimmed() : text;
+}
+
+void place(const Section &s, const QString &position, const QSizeF &screen, QVariantMap &into)
+{
+    const QPointF pos = layout(s.values.value(QStringLiteral("position"), position), screen);
+    into.insert(QStringLiteral("x"), pos.x());
+    into.insert(QStringLiteral("y"), pos.y());
+    into.insert(QStringLiteral("halign"), s.values.value(QStringLiteral("halign"), QStringLiteral("center")));
+    into.insert(QStringLiteral("valign"), s.values.value(QStringLiteral("valign"), QStringLiteral("center")));
+    into.insert(QStringLiteral("rotate"), s.values.value(QStringLiteral("rotate"), QStringLiteral("0")).toDouble());
+}
+
+QColor colorOr(const QString &value, const QColor &fallback)
+{
+    const QColor c = LockPreview::color(value);
+    return c.isValid() ? c : fallback;
+}
+
+// swaylock's colours: RRGGBB or RRGGBBAA, without a #.
+QColor hexColor(const QString &value, const QColor &fallback)
+{
+    QString v = value.trimmed();
+    if (v.startsWith(u'#')) {
+        v = v.mid(1);
+    }
+    bool ok = false;
+    const uint n = v.toUInt(&ok, 16);
+    if (!ok || (v.size() != 6 && v.size() != 8)) {
+        return fallback;
+    }
+    return v.size() == 6 ? QColor((n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff) : QColor((n >> 24) & 0xff, (n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff);
+}
+
+QVariantMap wallpaperOnly(const QUrl &wallpaper)
+{
+    return {{QStringLiteral("type"), QStringLiteral("background")},
+            {QStringLiteral("color"), QColor(0x11, 0x11, 0x11)},
+            {QStringLiteral("source"), wallpaper},
+            {QStringLiteral("fill"), QStringLiteral("fill")},
+            {QStringLiteral("blur"), 0.0},
+            {QStringLiteral("dim"), 0.0}};
+}
+} // namespace
+
+QColor LockPreview::color(const QString &value)
+{
+    const QString v = value.trimmed();
+    static const QRegularExpression call(QStringLiteral("^(rgba?)\\((.*)\\)$"));
+    const auto m = call.match(v);
+    if (m.hasMatch()) {
+        const QString inner = m.captured(2).trimmed();
+        const QStringList parts = inner.split(u',');
+        if (parts.size() >= 3) {
+            QColor c(parts.at(0).trimmed().toInt(), parts.at(1).trimmed().toInt(), parts.at(2).trimmed().toInt());
+            if (parts.size() >= 4) {
+                c.setAlphaF(std::clamp(parts.at(3).trimmed().toDouble(), 0.0, 1.0));
+            }
+            return c;
+        }
+        return hexColor(inner, {});
+    }
+    bool ok = false;
+    const qulonglong n = v.startsWith(u"0x", Qt::CaseInsensitive) ? v.mid(2).toULongLong(&ok, 16) : v.toULongLong(&ok, 10);
+    if (!ok) {
+        return {};
+    }
+    return QColor(int((n >> 16) & 0xff), int((n >> 8) & 0xff), int(n & 0xff), int((n >> 24) & 0xff));
+}
+
+QString LockPreview::locker()
+{
+    static const QStringList names{QStringLiteral("hyprlock"), QStringLiteral("swaylock"), QStringLiteral("gtklock"), QStringLiteral("waylock")};
+    // Where a lock screen is started from: the idle daemons first, then the
+    // keys. The first one named there, outside comments.
+    static const QStringList places{QStringLiteral("hypr/hypridle.conf"), QStringLiteral("swayidle/config"), QStringLiteral("niri/config.kdl"),
+                                    QStringLiteral("hypr/hyprland.lua"), QStringLiteral("hypr/hyprland.conf")};
+    for (const QString &place : places) {
+        for (const QString &line : readFile(configHome() + u'/' + place).split(u'\n')) {
+            const QString code = line.trimmed();
+            if (code.startsWith(u'#') || code.startsWith(u"//") || code.startsWith(u"--")) {
+                continue;
+            }
+            qsizetype first = -1;
+            QString found;
+            for (const QString &name : names) {
+                const qsizetype at = code.indexOf(name);
+                if (at >= 0 && (first < 0 || at < first)) {
+                    first = at;
+                    found = name;
+                }
+            }
+            if (!found.isEmpty()) {
+                return found;
+            }
+        }
+    }
+    // Started some other way (a script of its own): one that is set up.
+    if (!QStandardPaths::findExecutable(QStringLiteral("hyprlock")).isEmpty() && !findConfig(QStringLiteral("hypr/hyprlock.conf")).isEmpty()) {
+        return QStringLiteral("hyprlock");
+    }
+    for (const QString &name : names) {
+        if (!QStandardPaths::findExecutable(name).isEmpty()) {
+            return name;
+        }
+    }
+    return {};
+}
+
+QVariantList LockPreview::hyprlock(const QString &configPath, const QSizeF &screen, const QString &output, const QUrl &wallpaper)
+{
+    Hyprlang config;
+    config.parse(configPath);
+
+    bool trim = true;
+    for (const Section &s : std::as_const(config.sections)) {
+        if (s.name == u"general" && s.values.contains(QStringLiteral("text_trim"))) {
+            trim = truthy(s.values.value(QStringLiteral("text_trim")));
+        }
+    }
+
+    QElapsedTimer budget;
+    budget.start();
+    QList<QPair<int, QVariantMap>> placed;
+    bool ourLine = false;
+    bool background = false;
+    for (const Section &s : std::as_const(config.sections)) {
+        const auto value = [&s](const char *key, const char *fallback) {
+            return s.values.value(QString::fromLatin1(key), QString::fromLatin1(fallback));
+        };
+        const QString monitor = value("monitor", "");
+        if (!monitor.isEmpty() && monitor != output && !monitor.startsWith(u"desc:")) {
+            continue;
+        }
+        QVariantMap w;
+        int z = value("zindex", "0").toInt();
+        if (s.name == u"background") {
+            background = true;
+            z = value("zindex", "-1").toInt();
+            const QString path = value("path", "");
+            const int passes = value("blur_passes", "0").toInt();
+            w = wallpaperOnly(path == u"screenshot" ? wallpaper : path.isEmpty() ? QUrl() : QUrl::fromLocalFile(expandHome(path)));
+            w.insert(QStringLiteral("color"), colorOr(value("color", ""), QColor(0x11, 0x11, 0x11)));
+            w.insert(QStringLiteral("blur"), passes > 0 ? std::min(1.0, passes * value("blur_size", "8").toDouble() / 24.0) : 0.0);
+            // hyprlock's blur also darkens, by its brightness.
+            w.insert(QStringLiteral("dim"), passes > 0 ? std::clamp(1.0 - value("brightness", "0.8172").toDouble(), 0.0, 1.0) : 0.0);
+        } else if (s.name == u"label") {
+            const QString text = value("text", "Sample Text");
+            ourLine = ourLine || text.contains(u"face-unlock/lock-text");
+            w.insert(QStringLiteral("type"), QStringLiteral("label"));
+            w.insert(QStringLiteral("text"), styled(labelText(text, trim, budget)));
+            font(value("font_family", "Sans"), w);
+            w.insert(QStringLiteral("size"), value("font_size", "16").toDouble());
+            w.insert(QStringLiteral("color"), colorOr(value("color", ""), Qt::white));
+            w.insert(QStringLiteral("align"), value("text_align", "center"));
+            w.insert(QStringLiteral("shadow"), value("shadow_passes", "0").toInt() > 0);
+            w.insert(QStringLiteral("shadowSize"), value("shadow_size", "3").toDouble());
+            w.insert(QStringLiteral("shadowColor"), colorOr(value("shadow_color", ""), Qt::black));
+            place(s, QStringLiteral("0,0"), screen, w);
+        } else if (s.name == u"input-field") {
+            const QPointF size = layout(value("size", "400,90"), screen);
+            w.insert(QStringLiteral("type"), QStringLiteral("input"));
+            w.insert(QStringLiteral("width"), size.x());
+            w.insert(QStringLiteral("height"), size.y());
+            w.insert(QStringLiteral("thickness"), value("outline_thickness", "4").toDouble());
+            w.insert(QStringLiteral("outer"), gradient(value("outer_color", "0xFF111111")));
+            w.insert(QStringLiteral("inner"), colorOr(value("inner_color", ""), QColor(0xdd, 0xdd, 0xdd)));
+            w.insert(QStringLiteral("fontColor"), colorOr(value("font_color", ""), Qt::black));
+            font(value("font_family", "Sans"), w);
+            w.insert(QStringLiteral("placeholder"), styled(labelText(value("placeholder_text", "<i>Input Password</i>"), trim, budget)));
+            w.insert(QStringLiteral("rounding"), value("rounding", "-1").toDouble());
+            place(s, QStringLiteral("0,0"), screen, w);
+        } else if (s.name == u"shape") {
+            const QPointF size = layout(value("size", "100,100"), screen);
+            w.insert(QStringLiteral("type"), QStringLiteral("shape"));
+            w.insert(QStringLiteral("width"), size.x());
+            w.insert(QStringLiteral("height"), size.y());
+            w.insert(QStringLiteral("color"), colorOr(value("color", ""), QColor(0x11, 0x11, 0x11)));
+            w.insert(QStringLiteral("rounding"), value("rounding", "0").toDouble());
+            w.insert(QStringLiteral("borderSize"), value("border_size", "0").toDouble());
+            w.insert(QStringLiteral("border"), gradient(value("border_color", "0xFF00CFE6")));
+            place(s, QStringLiteral("0,0"), screen, w);
+        } else if (s.name == u"image") {
+            const QString path = value("path", "");
+            if (path.isEmpty()) {
+                continue;
+            }
+            w.insert(QStringLiteral("type"), QStringLiteral("image"));
+            w.insert(QStringLiteral("source"), QUrl::fromLocalFile(expandHome(path)));
+            w.insert(QStringLiteral("size"), value("size", "150").toDouble());
+            w.insert(QStringLiteral("rounding"), value("rounding", "-1").toDouble());
+            w.insert(QStringLiteral("borderSize"), value("border_size", "4").toDouble());
+            w.insert(QStringLiteral("border"), gradient(value("border_color", "0xFFDDDDDD")));
+            place(s, QStringLiteral("0,0"), screen, w);
+        } else {
+            continue;
+        }
+        placed.append({z, w});
+    }
+
+    if (!background) {
+        QVariantMap w = wallpaperOnly({});
+        placed.append({-1, w});
+    }
+    // face-unlock's line, as the menu puts it in (fu_hyprlock_text_on),
+    // for those who have not picked it yet.
+    if (!ourLine) {
+        QVariantMap w{{QStringLiteral("type"), QStringLiteral("label")},
+                      {QStringLiteral("text"), i18n("Looking for your face…").toHtmlEscaped()},
+                      {QStringLiteral("size"), 20.0},
+                      {QStringLiteral("color"), QColor(255, 255, 255, 242)},
+                      {QStringLiteral("align"), QStringLiteral("center")},
+                      {QStringLiteral("shadow"), true},
+                      {QStringLiteral("shadowSize"), 3.0},
+                      {QStringLiteral("shadowColor"), QColor(Qt::black)},
+                      {QStringLiteral("x"), 0.0},
+                      {QStringLiteral("y"), -48.0},
+                      {QStringLiteral("halign"), QStringLiteral("center")},
+                      {QStringLiteral("valign"), QStringLiteral("top")},
+                      {QStringLiteral("rotate"), 0.0}};
+        font(QStringLiteral("Sans"), w);
+        placed.append({10, w});
+    }
+
+    std::stable_sort(placed.begin(), placed.end(), [](const auto &a, const auto &b) {
+        return a.first < b.first;
+    });
+    QVariantList widgets;
+    for (const auto &p : std::as_const(placed)) {
+        widgets.append(p.second);
+    }
+    return widgets;
+}
+
+QVariantList LockPreview::swaylock(const QString &configPath, const QUrl &wallpaper)
+{
+    // One option per line, as on the command line without the dashes.
+    QHash<QString, QString> o;
+    for (const QString &raw : readFile(configPath).split(u'\n')) {
+        const QString line = raw.trimmed();
+        if (line.isEmpty() || line.startsWith(u'#')) {
+            continue;
+        }
+        o.insert(line.section(u'=', 0, 0).trimmed(), line.contains(u'=') ? line.section(u'=', 1).trimmed() : QString());
+    }
+
+    // An image may name its output first: [[<output>]:]<path>.
+    QString image = o.value(QStringLiteral("image"));
+    if (image.contains(u':') && !image.startsWith(u'/') && !image.startsWith(u'~')) {
+        image = image.section(u':', 1);
+    }
+    QVariantMap bg = wallpaperOnly(o.contains(QStringLiteral("screenshots")) ? wallpaper
+                                       : image.isEmpty()                    ? QUrl()
+                                                                            : QUrl::fromLocalFile(expandHome(image)));
+    bg.insert(QStringLiteral("color"), hexColor(o.value(QStringLiteral("color")), Qt::white));
+    bg.insert(QStringLiteral("fill"), o.value(QStringLiteral("scaling"), QStringLiteral("fill")));
+    // swaylock-effects: effect-blur=<radius>x<times>.
+    const QString blur = o.value(QStringLiteral("effect-blur"));
+    if (!blur.isEmpty()) {
+        bg.insert(QStringLiteral("blur"), std::min(1.0, blur.section(u'x', 0, 0).toDouble() * blur.section(u'x', 1, 1).toDouble() / 24.0));
+    }
+    QVariantList widgets{bg};
+
+    // The ring shows only while typing, unless it is asked to stay.
+    const bool clock = o.contains(QStringLiteral("clock"));
+    if (o.contains(QStringLiteral("indicator")) || o.contains(QStringLiteral("indicator-idle-visible")) || clock) {
+        const QDateTime now = QDateTime::currentDateTime();
+        widgets.append(QVariantMap{
+            {QStringLiteral("type"), QStringLiteral("ring")},
+            {QStringLiteral("radius"), o.value(QStringLiteral("indicator-radius"), QStringLiteral("50")).toDouble()},
+            {QStringLiteral("thickness"), o.value(QStringLiteral("indicator-thickness"), QStringLiteral("10")).toDouble()},
+            {QStringLiteral("inside"), hexColor(o.value(QStringLiteral("inside-color")), QColor(0, 0, 0, 0xc0))},
+            {QStringLiteral("ring"), hexColor(o.value(QStringLiteral("ring-color")), QColor(0x33, 0x7d, 0x00))},
+            {QStringLiteral("textColor"), hexColor(o.value(QStringLiteral("text-color")), QColor(0xe5, 0xa4, 0x45))},
+            {QStringLiteral("text"), clock ? now.toString(QStringLiteral("HH:mm")) + u'\n' + now.toString(QStringLiteral("yyyy-MM-dd")) : QString()},
+        });
+    }
+    return widgets;
+}
+
+QVariantList LockPreview::widgets(const QString &locker, const QSizeF &screen, const QString &output, const QUrl &wallpaper)
+{
+    if (locker == u"hyprlock") {
+        const QString path = findConfig(QStringLiteral("hypr/hyprlock.conf"));
+        if (!path.isEmpty()) {
+            return hyprlock(path, screen, output, wallpaper);
+        }
+    } else if (locker == u"swaylock") {
+        QString path = findConfig(QStringLiteral("swaylock/config"));
+        if (path.isEmpty() && QFileInfo::exists(QDir::homePath() + QStringLiteral("/.swaylock/config"))) {
+            path = QDir::homePath() + QStringLiteral("/.swaylock/config");
+        }
+        return swaylock(path, wallpaper);
+    }
+    // Something this does not know how to draw: the desktop's picture.
+    return {wallpaperOnly(wallpaper)};
+}