Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.
// SPDX-License-Identifier: GPL-3.0-or-later
#include "app_helpers.h"
#include "video_view.h"
#include <QtCore/QCoreApplication>
#include <QtCore/QDateTime>
#include <QtCore/QDir>
#include <QtCore/QFileInfo>
#include <QtCore/QLibraryInfo>
#include <QtCore/QLocale>
#include <QtCore/QMimeData>
#include <QtCore/QPointer>
#include <QtCore/QStorageInfo>
#include <QtCore/QStringList>
#include <QtCore/QTimeZone>
#include <QtCore/QTranslator>
#include <QtCore/QUrl>
#include <QtCore/QtEnvironmentVariables>
#include <QtGui/QDrag>
#include <QtGui/QFontDatabase>
#include <QtGui/QGuiApplication>
#include <QtGui/QIcon>
#include <QtGui/QImage>
#include <QtGui/QPixmap>
#include <QtGui/QPixmapCache>
#include <QtQml/QQmlApplicationEngine>
#include <QtQml/QQmlEngine>
#include <QtQuick/QQuickWindow>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <malloc.h>
#endif
#ifdef __linux__
#include <QtCore/QBuffer>
#include <QtCore/QMetaObject>
#include <QtCore/QThread>
#include <QtGui/QAction>
#include <QtGui/QClipboard>
#include <QtGui/QScreen>
#include <QtWidgets/QApplication>
#include <QtWidgets/QMenu>
#include <QtWidgets/QSystemTrayIcon>
#include <chrono>
#include <condition_variable>
#include <deque>
#include <mutex>
#endif
namespace {
QIcon &appIcon()
{
static QIcon icon;
return icon;
}
QPointer<QQmlEngine> &qmlEngineRef()
{
static QPointer<QQmlEngine> engine;
return engine;
}
// Every QML engine registered, for retranslating them all when the
// language changes (gone ones drop out on their own).
QList<QPointer<QQmlEngine>> &allEngines()
{
static QList<QPointer<QQmlEngine>> engines;
return engines;
}
void remember(QQmlEngine *engine)
{
auto &engines = allEngines();
engines.removeIf([](const QPointer<QQmlEngine> &e) { return e.isNull(); });
if (!engines.contains(engine))
engines.append(engine);
}
} // namespace
void register_qml_engine(QQmlEngine *engine)
{
if (engine) {
qmlEngineRef() = engine;
remember(engine);
}
}
void register_qml_app_engine(QQmlApplicationEngine &engine)
{
qmlEngineRef() = &engine;
remember(&engine);
}
#include <QtCore/QDateTime>
#include <QtCore/QFile>
#include <QtCore/QTextStream>
#include <atomic>
#include <cstdio>
namespace {
std::atomic<int> &qmlProblems()
{
static std::atomic<int> count { 0 };
return count;
}
// A warning or error from QML: a component that didn't load, a binding or
// a script that failed.
bool isQmlProblem(QtMsgType type, const QMessageLogContext &ctx, const QString &msg)
{
if (type != QtWarningMsg && type != QtCriticalMsg && type != QtFatalMsg)
return false;
return (ctx.file && QByteArray(ctx.file).startsWith("qrc:/")) || msg.contains(QStringLiteral("qrc:/"));
}
// `--ui-check`: messages go to stderr, not the log file, and QML problems
// are counted.
void uiCheckMessageHandler(QtMsgType type, const QMessageLogContext &ctx, const QString &msg)
{
if (type == QtDebugMsg)
return;
if (isQmlProblem(type, ctx, msg))
qmlProblems().fetch_add(1);
std::fprintf(stderr, "[%d] %s (%s:%d)\n", int(type), qUtf8Printable(msg), ctx.file ? ctx.file : "", ctx.line);
std::fflush(stderr);
}
// The app's logs folder (`<data>/logs`), so a test instance with its own
// data folder doesn't write into the installed app's.
QString &qmlLogDir()
{
static QString dir;
return dir;
}
void qtLogMessageHandler(QtMsgType type, const QMessageLogContext &ctx, const QString &msg)
{
if (type == QtDebugMsg)
return;
const QString &dirPath = qmlLogDir();
if (dirPath.isEmpty())
return;
QDir().mkpath(dirPath);
QFile file(dirPath + QStringLiteral("/qml.log"));
if (file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) {
QTextStream ts(&file);
ts << QDateTime::currentDateTimeUtc().toString(Qt::ISODate) << " [" << type << "] "
<< msg << " (" << (ctx.file ? ctx.file : "") << ":" << ctx.line << ")\n";
}
}
} // namespace
void prepare_qt(rust::Str log_dir)
{
qmlLogDir() = QString::fromUtf8(log_dir.data(), static_cast<qsizetype>(log_dir.size()));
qInstallMessageHandler(qtLogMessageHandler);
prepare_qt_without_log();
}
void prepare_qt_for_ui_check()
{
qInstallMessageHandler(uiCheckMessageHandler);
prepare_qt_without_log();
}
int32_t qml_problem_count()
{
return qmlProblems().load();
}
void prepare_qt_without_log()
{
// Windows get an alpha channel so the Mica backdrop can show through, and
// D3D swap chains are presented with DirectComposition, without which
// transparent pixels render white (see spikes/s1-qt-rust, lesson 7).
QQuickWindow::setDefaultAlphaBuffer(true);
qputenv("QT_QPA_DISABLE_REDIRECTION_SURFACE", "1");
qputenv("QSG_RENDER_LOOP", "basic");
// Qt's V4 JS engine reserves 2 x QV4_JS_MAX_STACK_SIZE of committed RW
// memory (8 MB by default). 512 KB per stack (1 MB total) is plenty for
// UI bindings and saves 7 MB of private commit in the tray.
qputenv("QV4_JS_MAX_STACK_SIZE", "524288");
}
void add_app_icon_image(int32_t size, rust::Slice<const uint8_t> rgba)
{
if (size <= 0 || rgba.size() != static_cast<size_t>(size) * size * 4)
return;
// Copy: the image must not reference Rust memory after this call.
const QImage image =
QImage(rgba.data(), size, size, size * 4, QImage::Format_RGBA8888).copy();
appIcon().addPixmap(QPixmap::fromImage(image));
}
void apply_app_icon()
{
QGuiApplication::setWindowIcon(appIcon());
}
void keep_running_without_windows()
{
QGuiApplication::setQuitOnLastWindowClosed(false);
}
int32_t load_bundled_fonts()
{
int32_t loaded = 0;
const QDir dir(QStringLiteral(":/fonts"));
for (const QString &name : dir.entryList({QStringLiteral("*.ttf")}, QDir::Files)) {
if (QFontDatabase::addApplicationFont(dir.filePath(name)) >= 0)
++loaded;
}
return loaded;
}
void trim_memory_caches()
{
clear_idle_video_frames();
QPixmapCache::clear();
if (QQmlEngine *engine = qmlEngineRef().data()) {
engine->collectGarbage();
engine->trimComponentCache();
engine->collectGarbage();
}
#ifdef _WIN32
_heapmin();
HANDLE heaps[64];
const DWORD count = GetProcessHeaps(64, heaps);
for (DWORD i = 0; i < count && i < 64; ++i) {
HeapCompact(heaps[i], 0);
}
SetProcessWorkingSetSize(GetCurrentProcess(), static_cast<SIZE_T>(-1), static_cast<SIZE_T>(-1));
#endif
}
bool start_external_drag(rust::Str file_path, rust::Str text_fallback)
{
const QString path = QString::fromUtf8(file_path.data(), static_cast<qsizetype>(file_path.size())).trimmed();
const QString text = QString::fromUtf8(text_fallback.data(), static_cast<qsizetype>(text_fallback.size()));
if (path.isEmpty() && text.isEmpty())
return false;
auto *mime = new QMimeData();
QPixmap dragPixmap;
if (!path.isEmpty() && QFileInfo::exists(path)) {
mime->setUrls({QUrl::fromLocalFile(path)});
QImage img(path);
if (!img.isNull()) {
mime->setImageData(img);
dragPixmap = QPixmap::fromImage(img.scaled(96, 96, Qt::KeepAspectRatio, Qt::SmoothTransformation));
}
} else if (!text.isEmpty()) {
mime->setText(text);
} else {
delete mime;
return false;
}
QDrag drag(QGuiApplication::instance());
drag.setMimeData(mime);
if (!dragPixmap.isNull())
drag.setPixmap(dragPixmap);
return drag.exec(Qt::CopyAction) != Qt::IgnoreAction;
}
namespace {
// The translators installed now, replaced when the language changes.
QPointer<QTranslator> &qtTranslator()
{
static QPointer<QTranslator> t;
return t;
}
QPointer<QTranslator> &appTranslator()
{
static QPointer<QTranslator> t;
return t;
}
void drop(QPointer<QTranslator> &translator)
{
if (translator) {
QCoreApplication::removeTranslator(translator);
delete translator.data();
}
translator = nullptr;
}
} // namespace
bool install_translator(rust::Str dir, rust::Str language)
{
const QString folder = QString::fromUtf8(dir.data(), static_cast<qsizetype>(dir.size()));
const QString chosen = QString::fromUtf8(language.data(), static_cast<qsizetype>(language.size()));
const QLocale locale = chosen.isEmpty() ? QLocale::system() : QLocale(chosen);
QLocale::setDefault(locale);
drop(qtTranslator());
drop(appTranslator());
// Qt's own strings: file dialogs, context menus, the standard buttons.
// windeployqt stages a merged `qt_<locale>.qm` in `translations/` beside the
// executable, while a build from source finds `qtbase_<locale>.qm` in Qt's
// own folder, so try both names in both places.
const QStringList qtDirs{
folder + QStringLiteral("/translations"),
QLibraryInfo::path(QLibraryInfo::TranslationsPath),
};
for (const QString &qtDir : qtDirs) {
for (const char *name : {"qtbase", "qt"}) {
auto *qt = new QTranslator(QCoreApplication::instance());
if (qt->load(locale, QString::fromLatin1(name), QStringLiteral("_"), qtDir)) {
QCoreApplication::installTranslator(qt);
qtTranslator() = qt;
break;
}
delete qt;
}
if (qtTranslator())
break;
}
// NectarLink's own strings, staged beside the executable. A locale with no
// translation (`nectarlink_es_ES.qm` missing), or English, stays English.
bool installed = false;
auto *app = new QTranslator(QCoreApplication::instance());
if (app->load(locale, QStringLiteral("nectarlink"), QStringLiteral("_"), folder)) {
installed = QCoreApplication::installTranslator(app);
appTranslator() = app;
} else {
delete app;
}
// Windows already open show the new language at once.
for (const QPointer<QQmlEngine> &engine : allEngines()) {
if (engine)
engine->retranslate();
}
return installed;
}
rust::String translate(rust::Str context, rust::Str text)
{
const std::string c(context.data(), context.size());
const std::string t(text.data(), text.size());
return rust::String(QCoreApplication::translate(c.c_str(), t.c_str()).toStdString());
}
rust::Vec<uint8_t> decode_image(rust::Slice<const uint8_t> bytes)
{
rust::Vec<uint8_t> result;
if (bytes.empty())
return result;
QImage img;
if (!img.loadFromData(bytes.data(), static_cast<int>(bytes.size())))
return result;
const QImage argb = img.convertToFormat(QImage::Format_ARGB32);
const uint32_t width = static_cast<uint32_t>(argb.width());
const uint32_t height = static_cast<uint32_t>(argb.height());
const size_t byteCount = static_cast<size_t>(argb.sizeInBytes());
result.reserve(8 + byteCount);
for (int i = 0; i < 4; ++i)
result.push_back(static_cast<uint8_t>((width >> (i * 8)) & 0xFF));
for (int i = 0; i < 4; ++i)
result.push_back(static_cast<uint8_t>((height >> (i * 8)) & 0xFF));
const uint8_t *bits = argb.constBits();
for (size_t i = 0; i < byteCount; ++i)
result.push_back(bits[i]);
return result;
}
#ifdef __APPLE__
#include <objc/runtime.h>
#include <objc/message.h>
extern "C" void *objc_autoreleasePoolPush(void);
extern "C" void objc_autoreleasePoolPop(void *pool);
namespace {
struct AutoReleasePool {
void *pool;
AutoReleasePool() : pool(objc_autoreleasePoolPush()) {}
~AutoReleasePool() { objc_autoreleasePoolPop(pool); }
};
} // namespace
int64_t mac_clipboard_change_count()
{
AutoReleasePool pool;
id pboardClass = reinterpret_cast<id>(objc_getClass("NSPasteboard"));
if (!pboardClass)
return 0;
id pboard = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(pboardClass, sel_registerName("generalPasteboard"));
if (!pboard)
return 0;
return reinterpret_cast<int64_t (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("changeCount"));
}
rust::String mac_clipboard_read_text(bool &is_private)
{
AutoReleasePool pool;
is_private = false;
id pboardClass = reinterpret_cast<id>(objc_getClass("NSPasteboard"));
if (!pboardClass)
return rust::String();
id pboard = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(pboardClass, sel_registerName("generalPasteboard"));
if (!pboard)
return rust::String();
id strClass = reinterpret_cast<id>(objc_getClass("NSString"));
if (!strClass)
return rust::String();
id concealed = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "org.nspasteboard.ConcealedType");
id transient = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "org.nspasteboard.TransientType");
id autoGen = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "org.nspasteboard.AutoGeneratedType");
id plainTextType = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "public.utf8-plain-text");
for (int attempt = 0; attempt < 2; ++attempt) {
int64_t countBefore = reinterpret_cast<int64_t (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("changeCount"));
id types = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("types"));
if (types) {
if ((concealed && reinterpret_cast<bool (*)(id, SEL, id)>(objc_msgSend)(types, sel_registerName("containsObject:"), concealed))
|| (transient && reinterpret_cast<bool (*)(id, SEL, id)>(objc_msgSend)(types, sel_registerName("containsObject:"), transient))
|| (autoGen && reinterpret_cast<bool (*)(id, SEL, id)>(objc_msgSend)(types, sel_registerName("containsObject:"), autoGen))) {
int64_t countAfter = reinterpret_cast<int64_t (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("changeCount"));
if (countBefore == countAfter) {
is_private = true;
return rust::String();
}
continue;
}
}
id str = reinterpret_cast<id (*)(id, SEL, id)>(objc_msgSend)(pboard, sel_registerName("stringForType:"), plainTextType);
int64_t countAfter = reinterpret_cast<int64_t (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("changeCount"));
if (countBefore != countAfter) {
continue;
}
if (str) {
const char *utf8 = reinterpret_cast<const char * (*)(id, SEL)>(objc_msgSend)(str, sel_registerName("UTF8String"));
if (utf8)
return rust::String(utf8);
}
return rust::String();
}
is_private = false;
return rust::String();
}
bool mac_clipboard_write_text(rust::Str text, bool is_private)
{
AutoReleasePool pool;
id pboardClass = reinterpret_cast<id>(objc_getClass("NSPasteboard"));
if (!pboardClass)
return false;
id pboard = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(pboardClass, sel_registerName("generalPasteboard"));
if (!pboard)
return false;
reinterpret_cast<void (*)(id, SEL)>(objc_msgSend)(pboard, sel_registerName("clearContents"));
id strClass = reinterpret_cast<id>(objc_getClass("NSString"));
if (!strClass)
return false;
const std::string text_str(text.data(), text.size());
id nsStr = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), text_str.c_str());
if (!nsStr)
return false;
id plainTextType = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "public.utf8-plain-text");
id arrClass = reinterpret_cast<id>(objc_getClass("NSArray"));
if (!arrClass)
return false;
if (is_private) {
id concealed = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "org.nspasteboard.ConcealedType");
id transient = reinterpret_cast<id (*)(id, SEL, const char *)>(objc_msgSend)(
strClass, sel_registerName("stringWithUTF8String:"), "org.nspasteboard.TransientType");
const id items[] = { plainTextType, concealed, transient };
id types = reinterpret_cast<id (*)(id, SEL, const id *, unsigned long)>(objc_msgSend)(
arrClass, sel_registerName("arrayWithObjects:count:"), items, 3);
reinterpret_cast<void (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("declareTypes:owner:"), types, nullptr);
bool ok = reinterpret_cast<bool (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("setString:forType:"), nsStr, plainTextType);
if (!ok)
return false;
id dataClass = reinterpret_cast<id>(objc_getClass("NSData"));
if (dataClass) {
id emptyData = reinterpret_cast<id (*)(id, SEL)>(objc_msgSend)(dataClass, sel_registerName("data"));
reinterpret_cast<bool (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("setData:forType:"), emptyData, concealed);
reinterpret_cast<bool (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("setData:forType:"), emptyData, transient);
}
return true;
} else {
const id items[] = { plainTextType };
id types = reinterpret_cast<id (*)(id, SEL, const id *, unsigned long)>(objc_msgSend)(
arrClass, sel_registerName("arrayWithObjects:count:"), items, 1);
reinterpret_cast<void (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("declareTypes:owner:"), types, nullptr);
return reinterpret_cast<bool (*)(id, SEL, id, id)>(objc_msgSend)(
pboard, sel_registerName("setString:forType:"), nsStr, plainTextType);
}
}
#else
int64_t mac_clipboard_change_count()
{
return 0;
}
rust::String mac_clipboard_read_text(bool &is_private)
{
is_private = false;
return rust::String();
}
bool mac_clipboard_write_text(rust::Str /*text*/, bool /*is_private*/)
{
return false;
}
#endif
int64_t mac_local_offset_ms(int64_t at_ms)
{
const QDateTime dt = QDateTime::fromMSecsSinceEpoch(at_ms, QTimeZone::systemTimeZone());
return static_cast<int64_t>(dt.offsetFromUtc()) * 1000;
}
uint64_t mac_free_space(rust::Str path, bool &ok)
{
ok = false;
const std::string pathStr(path.data(), path.size());
QString qpath = QString::fromStdString(pathStr);
QFileInfo info(qpath);
while (!info.exists() && !qpath.isEmpty()) {
const QString parent = info.dir().absolutePath();
if (parent == qpath)
break;
qpath = parent;
info.setFile(qpath);
}
const QStorageInfo storage(qpath);
if (!storage.isValid() || !storage.isReady())
return 0;
const qint64 available = storage.bytesAvailable();
if (available < 0)
return 0;
ok = true;
return static_cast<uint64_t>(available);
}
#ifdef __linux__
namespace {
std::atomic<bool> &qtEventLoopRunning()
{
static std::atomic<bool> running { false };
return running;
}
struct LinuxClipboardWatch {
std::mutex mutex;
std::condition_variable cv;
std::atomic<uint64_t> seq { 1 };
};
LinuxClipboardWatch &linuxClipboardWatch()
{
static LinuxClipboardWatch *watch = new LinuxClipboardWatch();
return *watch;
}
struct LinuxTrayState {
QPointer<QSystemTrayIcon> icon;
QPointer<QMenu> menu;
QPointer<QAction> takePhotoAction;
QPointer<QAction> scanDocumentAction;
QPointer<QAction> findPhoneAction;
QPointer<QAction> openLinkAction;
bool phoneActionsEnabled = false;
std::mutex mutex;
std::condition_variable cv;
std::deque<std::string> actions;
};
LinuxTrayState &linuxTray()
{
static LinuxTrayState *state = new LinuxTrayState();
return *state;
}
void pushTrayAction(const char *action)
{
auto &st = linuxTray();
{
std::lock_guard<std::mutex> lock(st.mutex);
st.actions.emplace_back(action);
}
st.cv.notify_all();
}
template <typename F>
void runOnQtMainThread(F &&fn)
{
QCoreApplication *app = QCoreApplication::instance();
if (!app)
return;
if (QThread::currentThread() == app->thread()) {
fn();
} else {
QMetaObject::invokeMethod(app, std::forward<F>(fn), Qt::QueuedConnection);
}
}
template <typename F>
bool runOnQtMainThreadSync(F &&fn, uint32_t timeout_ms = 500)
{
QCoreApplication *app = QCoreApplication::instance();
if (!app)
return false;
if (QThread::currentThread() == app->thread()) {
fn();
return true;
}
if (!qtEventLoopRunning().load(std::memory_order_acquire))
return false;
struct SyncState {
std::mutex mutex;
std::condition_variable cv;
bool done = false;
};
auto state = std::make_shared<SyncState>();
auto task = std::make_shared<std::decay_t<F>>(std::forward<F>(fn));
QMetaObject::invokeMethod(
app,
[state, task]() {
(*task)();
{
std::lock_guard<std::mutex> lock(state->mutex);
state->done = true;
}
state->cv.notify_all();
},
Qt::QueuedConnection);
std::unique_lock<std::mutex> lock(state->mutex);
return state->cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [&state]() {
return state->done;
});
}
} // namespace
#endif
std::unique_ptr<QGuiApplication> create_qt_app()
{
static int s_argc = 1;
static char s_arg0[] = "nectarlink";
static char *s_argv[] = { s_arg0, nullptr };
#ifdef __linux__
auto app = std::unique_ptr<QGuiApplication>(new QApplication(s_argc, s_argv));
QObject::connect(app.get(), &QCoreApplication::aboutToQuit, app.get(), []() {
qtEventLoopRunning().store(false, std::memory_order_release);
});
QMetaObject::invokeMethod(
app.get(),
[]() {
qtEventLoopRunning().store(true, std::memory_order_release);
},
Qt::QueuedConnection);
if (QClipboard *cb = QGuiApplication::clipboard()) {
QObject::connect(cb, &QClipboard::dataChanged, cb, []() {
linux_clipboard_notify_external();
});
}
return app;
#else
return std::make_unique<QGuiApplication>(s_argc, s_argv);
#endif
}
void linux_tray_setup(
rust::Str icon_path,
rust::Str tooltip,
rust::Str open_label,
rust::Str command_palette_label,
rust::Str shelf_label,
rust::Str take_photo_label,
rust::Str scan_document_label,
rust::Str find_phone_label,
rust::Str open_link_label,
rust::Str quit_label)
{
#ifdef __linux__
const QString iconPath = QString::fromUtf8(icon_path.data(), static_cast<qsizetype>(icon_path.size()));
const QString tooltipStr = QString::fromUtf8(tooltip.data(), static_cast<qsizetype>(tooltip.size()));
const QString openStr = QString::fromUtf8(open_label.data(), static_cast<qsizetype>(open_label.size()));
const QString paletteStr = QString::fromUtf8(command_palette_label.data(), static_cast<qsizetype>(command_palette_label.size()));
const QString shelfStr = QString::fromUtf8(shelf_label.data(), static_cast<qsizetype>(shelf_label.size()));
const QString photoStr = QString::fromUtf8(take_photo_label.data(), static_cast<qsizetype>(take_photo_label.size()));
const QString scanStr = QString::fromUtf8(scan_document_label.data(), static_cast<qsizetype>(scan_document_label.size()));
const QString findPhoneStr = QString::fromUtf8(find_phone_label.data(), static_cast<qsizetype>(find_phone_label.size()));
const QString openLinkStr = QString::fromUtf8(open_link_label.data(), static_cast<qsizetype>(open_link_label.size()));
const QString quitStr = QString::fromUtf8(quit_label.data(), static_cast<qsizetype>(quit_label.size()));
runOnQtMainThread([=]() {
if (!qobject_cast<QApplication *>(QCoreApplication::instance()))
return;
auto &st = linuxTray();
if (st.icon) {
st.icon->hide();
delete st.icon.data();
}
if (st.menu) {
delete st.menu.data();
}
{
std::lock_guard<std::mutex> lock(st.mutex);
st.actions.clear();
}
// Menu order matches win/tray.rs:
// Take Photo, Scan Document, Separator, Open, Command Palette, Shelf, Find Phone, Open Link, Separator, Quit.
const bool enabled = st.phoneActionsEnabled;
auto *menu = new QMenu();
QAction *takePhoto = menu->addAction(photoStr);
takePhoto->setEnabled(enabled);
QObject::connect(takePhoto, &QAction::triggered, menu, []() { pushTrayAction("TAKE_PHOTO"); });
QAction *scanDoc = menu->addAction(scanStr);
scanDoc->setEnabled(enabled);
QObject::connect(scanDoc, &QAction::triggered, menu, []() { pushTrayAction("SCAN_DOCUMENT"); });
menu->addSeparator();
QObject::connect(menu->addAction(openStr), &QAction::triggered, menu, []() { pushTrayAction("OPEN"); });
QObject::connect(menu->addAction(paletteStr), &QAction::triggered, menu, []() { pushTrayAction("COMMAND_PALETTE"); });
QObject::connect(menu->addAction(shelfStr), &QAction::triggered, menu, []() { pushTrayAction("SHELF"); });
QAction *findPhone = menu->addAction(findPhoneStr);
findPhone->setEnabled(enabled);
QObject::connect(findPhone, &QAction::triggered, menu, []() { pushTrayAction("FIND_PHONE"); });
QAction *openLink = menu->addAction(openLinkStr);
openLink->setEnabled(enabled);
QObject::connect(openLink, &QAction::triggered, menu, []() { pushTrayAction("OPEN_LINK"); });
menu->addSeparator();
QObject::connect(menu->addAction(quitStr), &QAction::triggered, menu, []() { pushTrayAction("QUIT"); });
auto *tray = new QSystemTrayIcon(QCoreApplication::instance());
QIcon icon = appIcon();
if (icon.isNull() && !iconPath.isEmpty())
icon = QIcon(iconPath);
tray->setIcon(icon);
tray->setToolTip(tooltipStr);
tray->setContextMenu(menu);
QObject::connect(tray, &QSystemTrayIcon::activated, tray, [](QSystemTrayIcon::ActivationReason reason) {
if (reason == QSystemTrayIcon::Trigger || reason == QSystemTrayIcon::DoubleClick)
pushTrayAction("OPEN");
});
tray->show();
st.icon = tray;
st.menu = menu;
st.takePhotoAction = takePhoto;
st.scanDocumentAction = scanDoc;
st.findPhoneAction = findPhone;
st.openLinkAction = openLink;
});
#else
(void)icon_path;
(void)tooltip;
(void)open_label;
(void)command_palette_label;
(void)shelf_label;
(void)take_photo_label;
(void)scan_document_label;
(void)find_phone_label;
(void)open_link_label;
(void)quit_label;
#endif
}
void linux_tray_set_tooltip(rust::Str tooltip)
{
#ifdef __linux__
const QString tooltipStr = QString::fromUtf8(tooltip.data(), static_cast<qsizetype>(tooltip.size()));
runOnQtMainThread([tooltipStr]() {
if (auto *icon = linuxTray().icon.data())
icon->setToolTip(tooltipStr);
});
#else
(void)tooltip;
#endif
}
void linux_tray_set_find_phone_enabled(bool enabled)
{
#ifdef __linux__
runOnQtMainThread([enabled]() {
auto &st = linuxTray();
st.phoneActionsEnabled = enabled;
if (auto *act = st.takePhotoAction.data())
act->setEnabled(enabled);
if (auto *act = st.scanDocumentAction.data())
act->setEnabled(enabled);
if (auto *act = st.findPhoneAction.data())
act->setEnabled(enabled);
if (auto *act = st.openLinkAction.data())
act->setEnabled(enabled);
});
#else
(void)enabled;
#endif
}
void linux_tray_teardown()
{
#ifdef __linux__
auto &st = linuxTray();
st.cv.notify_all();
runOnQtMainThread([]() {
auto &s = linuxTray();
if (s.icon) {
s.icon->hide();
delete s.icon.data();
}
if (s.menu) {
delete s.menu.data();
}
s.takePhotoAction = nullptr;
s.scanDocumentAction = nullptr;
s.findPhoneAction = nullptr;
s.openLinkAction = nullptr;
});
#endif
}
rust::String linux_tray_wait_action(uint32_t timeout_ms)
{
#ifdef __linux__
auto &st = linuxTray();
std::unique_lock<std::mutex> lock(st.mutex);
if (st.actions.empty() && timeout_ms > 0) {
st.cv.wait_for(lock, std::chrono::milliseconds(timeout_ms));
}
if (!st.actions.empty()) {
std::string next = std::move(st.actions.front());
st.actions.pop_front();
return rust::String(next);
}
#else
(void)timeout_ms;
#endif
return rust::String();
}
bool linux_tray_is_available()
{
#ifdef __linux__
bool available = false;
if (runOnQtMainThreadSync([&available]() {
available = QSystemTrayIcon::isSystemTrayAvailable();
})) {
return available;
}
#endif
return false;
}
bool linux_work_area(int32_t &x, int32_t &y, int32_t &w, int32_t &h)
{
#ifdef __linux__
bool ok = false;
int32_t rx = 0, ry = 0, rw = 0, rh = 0;
if (runOnQtMainThreadSync([&]() {
if (QScreen *screen = QGuiApplication::primaryScreen()) {
const QRect avail = screen->availableGeometry();
const qreal dpr = screen->devicePixelRatio() > 0.0 ? screen->devicePixelRatio() : 1.0;
if (avail.width() > 0 && avail.height() > 0) {
rx = static_cast<int32_t>(avail.x() * dpr);
ry = static_cast<int32_t>(avail.y() * dpr);
rw = static_cast<int32_t>(avail.width() * dpr);
rh = static_cast<int32_t>(avail.height() * dpr);
ok = true;
}
}
})
&& ok) {
x = rx;
y = ry;
w = rw;
h = rh;
return true;
}
#else
(void)x;
(void)y;
(void)w;
(void)h;
#endif
return false;
}
bool linux_screen_geometry(int32_t &x, int32_t &y, int32_t &w, int32_t &h)
{
#ifdef __linux__
bool ok = false;
int32_t rx = 0, ry = 0, rw = 0, rh = 0;
if (runOnQtMainThreadSync([&]() {
if (QScreen *screen = QGuiApplication::primaryScreen()) {
const QRect geom = screen->geometry();
const qreal dpr = screen->devicePixelRatio() > 0.0 ? screen->devicePixelRatio() : 1.0;
if (geom.width() > 0 && geom.height() > 0) {
rx = static_cast<int32_t>(geom.x() * dpr);
ry = static_cast<int32_t>(geom.y() * dpr);
rw = static_cast<int32_t>(geom.width() * dpr);
rh = static_cast<int32_t>(geom.height() * dpr);
ok = true;
}
}
})
&& ok) {
x = rx;
y = ry;
w = rw;
h = rh;
return true;
}
#else
(void)x;
(void)y;
(void)w;
(void)h;
#endif
return false;
}
void linux_set_activation_token(rust::Str token)
{
#ifdef __linux__
if (token.empty())
return;
const QByteArray tok(token.data(), static_cast<qsizetype>(token.size()));
runOnQtMainThread([tok]() {
qputenv("XDG_ACTIVATION_TOKEN", tok);
});
#else
(void)token;
#endif
}
uint64_t linux_clipboard_sequence()
{
#ifdef __linux__
return linuxClipboardWatch().seq.load(std::memory_order_acquire);
#else
return 0;
#endif
}
uint64_t linux_clipboard_wait_change(uint64_t last_seq, uint32_t timeout_ms)
{
#ifdef __linux__
auto &w = linuxClipboardWatch();
uint64_t cur = w.seq.load(std::memory_order_acquire);
if (cur != last_seq || timeout_ms == 0)
return cur;
std::unique_lock<std::mutex> lock(w.mutex);
w.cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [&w, last_seq]() {
return w.seq.load(std::memory_order_acquire) != last_seq;
});
return w.seq.load(std::memory_order_acquire);
#else
(void)last_seq;
(void)timeout_ms;
return 0;
#endif
}
void linux_clipboard_notify_external()
{
#ifdef __linux__
auto &w = linuxClipboardWatch();
{
std::lock_guard<std::mutex> lock(w.mutex);
w.seq.fetch_add(1, std::memory_order_release);
}
w.cv.notify_all();
#endif
}
bool linux_clipboard_read(
bool check_privacy,
bool &is_private,
bool &has_files,
rust::String &text,
rust::String &html,
rust::String &rtf,
rust::Vec<uint8_t> &png_bytes)
{
is_private = false;
has_files = false;
text = rust::String();
html = rust::String();
rtf = rust::String();
png_bytes.clear();
#ifdef __linux__
bool ran = false;
bool priv = false;
bool files = false;
std::string outText;
std::string outHtml;
std::string outRtf;
QByteArray outPng;
if (!runOnQtMainThreadSync([&]() {
QClipboard *cb = QGuiApplication::clipboard();
if (!cb)
return;
ran = true;
const QMimeData *mime = cb->mimeData(QClipboard::Clipboard);
if (!mime)
return;
const QStringList formats = mime->formats();
if (check_privacy) {
for (const QString &fmt : formats) {
if (fmt.compare(QStringLiteral("x-gnome-privacy-hint"), Qt::CaseInsensitive) == 0
|| fmt.compare(QStringLiteral("ExcludeClipboardContentFromMonitorProcessing"), Qt::CaseInsensitive) == 0
|| fmt.compare(QStringLiteral("Clipboard Viewer Ignore"), Qt::CaseInsensitive) == 0) {
priv = true;
return;
}
if (fmt.compare(QStringLiteral("x-kde-passwordManagerHint"), Qt::CaseInsensitive) == 0) {
const QByteArray val = mime->data(fmt).trimmed();
if (val.isEmpty() || QString::fromUtf8(val).trimmed().compare(QStringLiteral("secret"), Qt::CaseInsensitive) == 0) {
priv = true;
return;
}
}
}
}
if (mime->hasFormat(QStringLiteral("image/png"))) {
outPng = mime->data(QStringLiteral("image/png"));
if (!outPng.isEmpty())
return;
}
if (mime->hasImage()) {
const QImage img = qvariant_cast<QImage>(mime->imageData());
if (!img.isNull()) {
QBuffer buf(&outPng);
if (buf.open(QIODevice::WriteOnly) && img.save(&buf, "PNG")) {
return;
}
outPng.clear();
}
}
for (const QString &fmt : formats) {
if (fmt.compare(QStringLiteral("x-special/gnome-copied-files"), Qt::CaseInsensitive) == 0
|| fmt.compare(QStringLiteral("x-special/mate-copied-files"), Qt::CaseInsensitive) == 0) {
files = true;
return;
}
}
if (mime->hasUrls()) {
for (const QUrl &u : mime->urls()) {
if (u.isLocalFile()) {
files = true;
return;
}
}
}
if (mime->hasText()) {
outText = mime->text().toStdString();
}
if (mime->hasHtml()) {
outHtml = mime->html().toStdString();
}
if (mime->hasFormat(QStringLiteral("text/rtf"))) {
const QByteArray r = mime->data(QStringLiteral("text/rtf"));
outRtf.assign(r.constData(), static_cast<size_t>(r.size()));
} else if (mime->hasFormat(QStringLiteral("application/rtf"))) {
const QByteArray r = mime->data(QStringLiteral("application/rtf"));
outRtf.assign(r.constData(), static_cast<size_t>(r.size()));
}
})) {
return false;
}
if (!ran)
return false;
is_private = priv;
has_files = files;
text = rust::String(outText);
html = rust::String(outHtml);
rtf = rust::String(outRtf);
if (!outPng.isEmpty()) {
png_bytes.reserve(static_cast<size_t>(outPng.size()));
const auto *raw = reinterpret_cast<const uint8_t *>(outPng.constData());
for (qsizetype i = 0; i < outPng.size(); ++i)
png_bytes.push_back(raw[i]);
}
return true;
#else
(void)check_privacy;
return false;
#endif
}
rust::Vec<rust::String> linux_clipboard_read_files()
{
rust::Vec<rust::String> result;
#ifdef __linux__
std::vector<std::string> paths;
if (runOnQtMainThreadSync([&]() {
QClipboard *cb = QGuiApplication::clipboard();
if (!cb)
return;
const QMimeData *mime = cb->mimeData(QClipboard::Clipboard);
if (!mime)
return;
if (mime->hasUrls()) {
for (const QUrl &u : mime->urls()) {
if (u.isLocalFile()) {
const QString local = u.toLocalFile();
if (!local.isEmpty() && QFileInfo::exists(local))
paths.push_back(local.toStdString());
}
}
}
if (paths.empty()) {
for (const char *fmt : { "x-special/gnome-copied-files", "x-special/mate-copied-files", "text/uri-list" }) {
const QString qfmt = QString::fromLatin1(fmt);
if (mime->hasFormat(qfmt)) {
const QString raw = QString::fromUtf8(mime->data(qfmt));
for (const QString &line : raw.split(QLatin1Char('\n'))) {
const QString trimmed = line.trimmed();
if (trimmed.startsWith(QStringLiteral("file://"))) {
const QUrl u(trimmed);
if (u.isLocalFile()) {
const QString local = u.toLocalFile();
if (!local.isEmpty() && QFileInfo::exists(local))
paths.push_back(local.toStdString());
}
}
}
if (!paths.empty())
break;
}
}
}
})) {
for (const std::string &p : paths)
result.push_back(rust::String(p));
}
#endif
return result;
}
bool linux_clipboard_write_text(rust::Str text, rust::Str html, rust::Str rtf, bool is_private)
{
#ifdef __linux__
const QString qtext = QString::fromUtf8(text.data(), static_cast<qsizetype>(text.size()));
const QString qhtml = QString::fromUtf8(html.data(), static_cast<qsizetype>(html.size()));
const QByteArray qrtf(rtf.data(), static_cast<qsizetype>(rtf.size()));
bool ok = false;
if (runOnQtMainThreadSync([&]() {
QClipboard *cb = QGuiApplication::clipboard();
if (!cb)
return;
auto *mime = new QMimeData();
mime->setText(qtext);
if (is_private) {
mime->setData(QStringLiteral("x-kde-passwordManagerHint"), QByteArrayLiteral("secret"));
mime->setData(QStringLiteral("x-gnome-privacy-hint"), QByteArrayLiteral("1"));
mime->setData(QStringLiteral("ExcludeClipboardContentFromMonitorProcessing"), QByteArrayLiteral("1"));
mime->setData(QStringLiteral("Clipboard Viewer Ignore"), QByteArrayLiteral("1"));
} else {
if (!qhtml.isEmpty())
mime->setHtml(qhtml);
if (!qrtf.isEmpty()) {
mime->setData(QStringLiteral("text/rtf"), qrtf);
mime->setData(QStringLiteral("application/rtf"), qrtf);
}
}
cb->setMimeData(mime, QClipboard::Clipboard);
ok = true;
})) {
return ok;
}
#else
(void)text;
(void)html;
(void)rtf;
(void)is_private;
#endif
return false;
}
bool linux_clipboard_write_image_png(rust::Slice<const uint8_t> png)
{
#ifdef __linux__
if (png.empty())
return false;
const QByteArray bytes(reinterpret_cast<const char *>(png.data()), static_cast<qsizetype>(png.size()));
bool ok = false;
if (runOnQtMainThreadSync([&]() {
QClipboard *cb = QGuiApplication::clipboard();
if (!cb)
return;
auto *mime = new QMimeData();
mime->setData(QStringLiteral("image/png"), bytes);
QImage img;
if (img.loadFromData(bytes, "PNG") && !img.isNull())
mime->setImageData(img);
cb->setMimeData(mime, QClipboard::Clipboard);
ok = true;
})) {
return ok;
}
#else
(void)png;
#endif
return false;
}
bool linux_clipboard_write_files(rust::Slice<const rust::String> paths)
{
#ifdef __linux__
if (paths.empty())
return false;
QList<QUrl> urls;
QByteArray gnomePayload("copy");
for (const rust::String &p : paths) {
const QString qp = QString::fromUtf8(p.data(), static_cast<qsizetype>(p.size()));
if (!qp.isEmpty()) {
const QUrl u = QUrl::fromLocalFile(qp);
urls.append(u);
gnomePayload.append('\n');
gnomePayload.append(u.toEncoded());
}
}
if (urls.isEmpty())
return false;
bool ok = false;
if (runOnQtMainThreadSync([&]() {
QClipboard *cb = QGuiApplication::clipboard();
if (!cb)
return;
auto *mime = new QMimeData();
mime->setUrls(urls);
mime->setData(QStringLiteral("x-special/gnome-copied-files"), gnomePayload);
mime->setData(QStringLiteral("x-special/mate-copied-files"), gnomePayload);
cb->setMimeData(mime, QClipboard::Clipboard);
ok = true;
})) {
return ok;
}
#else
(void)paths;
#endif
return false;
}