648 lines
27 KiB
C++
648 lines
27 KiB
C++
// 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)};
|
|
}
|