settingsdialog.cpp

#include "settingsdialog.h"
#include "a11y.h"
#include "logging.h"
#include "onscreenkeyboard.h"
#include "settingsjson.h"
#include "translations/tsparser.h"
#include "audioclicklistener.h"
#include "clickinjector.h"
#include <QApplication>
#include <QClipboard>
#include <QDir>
#include <QFile>
#include <QFileDialog>
#include <QInputDialog>
#include <QJsonDocument>
#include <QScrollArea>
#include <QSettings>
#include <QGuiApplication>
#include <QKeySequenceEdit>
#include <QCursor>
#include <QEvent>
#include <QFrame>
#include <QGraphicsOpacityEffect>
#include <QProgressBar>
#include <QTimer>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QFormLayout>
#include <QListWidget>
#include <QGroupBox>
#include <QLabel>
#include <QPainter>
#include <QAbstractButton>
#include <QPushButton>
#include <QSvgRenderer>
#include <QTabWidget>
#include <QMessageBox>
#include <QProcess>
#include <QProgressDialog>
#include <QStandardPaths>
#include <QSysInfo>
#include <cmath>
// Unconditional since the log section's "Open log folder" needs them on every
// platform; they used to be macOS-only (the Accessibility settings shortcut).
#include <QDesktopServices>
#include <QLocale>
#include <QUrl>

// ── TrackIR palette ──────────────────────────────────────────
// Settings-window font zoom: the base font size (at 100%) plus the bounds and
// step of the "+/-" zoom control that sits next to the language selector.  The
// stylesheet font-size is regenerated from this base whenever the user zooms.
static constexpr int kBaseFontPx  = 12;
static constexpr int kZoomMinPct  = 80;
static constexpr int kZoomMaxPct  = 200;
static constexpr int kZoomStepPct = 10;

// The version as shown to users, with the CI build number appended when the
// build defined one.  The version itself comes from applicationVersion(), which
// main.cpp seeds from the TRACKCLICK_VERSION compile definition — CMake's
// project(VERSION …) is the single source, so nothing here repeats the literal.
// Both the About header and the Diagnostics read-out call this, so the two can
// never disagree.
#ifdef BUILD_NUMBER
#  define TC_STR_(x) #x
#  define TC_STR(x) TC_STR_(x)
#endif
static QString displayVersion()
{
#ifdef BUILD_NUMBER
    return QCoreApplication::applicationVersion()
           + QStringLiteral(" (build " TC_STR(BUILD_NUMBER) ")");
#else
    return QCoreApplication::applicationVersion();
#endif
}

// Build the dialog stylesheet with every text element sized at fontPx, so the
// zoom control can scale the whole settings window just by re-applying it.
// The @FS@ token is substituted with the requested pixel size below.
static QString buildStyle(int fontPx)
{
    return QString(R"(
QDialog {
    background: #2D2D2D;
    color: #E6E6E6;
    font-family: "Segoe UI", Arial, sans-serif;
    font-size: @FS@px;
}
QGroupBox {
    color: #FFA600;
    border: 1px solid #3A3A3A;
    border-radius: 4px;
    margin-top: 10px;
    padding-top: 6px;
    font-size: @FS@px;
}
QGroupBox::title {
    subcontrol-origin: margin;
    left: 8px;
    padding: 0 4px;
}
QLabel  { color: #E6E6E6; font-size: @FS@px; }
QCheckBox { color: #E6E6E6; spacing: 6px; font-size: @FS@px; }
QCheckBox::indicator {
    width: 25px; height: 11px;
    border: none;
    border-radius: 0;
    background: transparent;
    image: url(:/icons/toggle_off.svg);
}
QCheckBox::indicator:checked {
    image: url(:/icons/toggle_on.svg);
}
QListWidget {
    background: #1A1A1A;
    color: #E6E6E6;
    border: 1px solid #555;
    border-radius: 3px;
    font-size: @FS@px;
    outline: none;
}
/* A background on the base item rule is deliberate: it forces every row through
   the stylesheet render path so the 25px QSS indicator width below is honoured
   for text layout.  Without it, unselected rows fall back to the native style
   (which reserves only its ~13px indicator metric) and the wide toggle overhangs
   the label on Windows — while selected rows, matching the :selected background
   rule, lay out correctly.  #1A1A1A matches the list background, so no visual
   change; it only fixes the text/toggle overlap. */
QListWidget::item { padding: 3px 4px; background: #1A1A1A; }
QListWidget::item:selected { background: #3D3D3D; color: #FFA600; }
QListWidget::indicator {
    width: 25px; height: 11px;
    background: transparent;
    image: url(:/icons/toggle_off.svg);
}
QListWidget::indicator:checked {
    image: url(:/icons/toggle_on.svg);
}
QSpinBox, QDoubleSpinBox, QComboBox, QLineEdit, QKeySequenceEdit {
    background: #1A1A1A;
    color: #E6E6E6;
    border: 1px solid #555;
    border-radius: 3px;
    padding: 2px 4px;
    font-size: @FS@px;
}
QLineEdit:focus, QKeySequenceEdit:focus {
    border: 1px solid #FFA600;
}
QComboBox::drop-down { border: none; width: 18px; }
QComboBox QAbstractItemView {
    background: #2D2D2D;
    color: #E6E6E6;
    border: 1px solid #555;
    selection-background-color: #FFA600;
    selection-color: #1A1A1A;
    font-size: @FS@px;
}
QSlider::groove:horizontal {
    height: 4px;
    background: #555;
    border-radius: 2px;
}
QSlider::handle:horizontal {
    width: 14px; height: 14px;
    background: #FFA600;
    border-radius: 7px;
    margin: -5px 0;
}
QSlider::sub-page:horizontal { background: #FFA600; border-radius: 2px; }
QPushButton {
    background: #FFA600;
    color: #1A1A1A;
    border: none;
    border-radius: 4px;
    padding: 6px 18px;
    font-weight: bold;
    font-size: @FS@px;
}
QPushButton:hover  { background: #FFB833; }
QPushButton:pressed{ background: #CC8400; }
QPushButton[flat=true] {
    background: #3D3D3D;
    color: #FFFFFF;
}
QPushButton[flat=true]:hover { background: #4D4D4D; }
QTabWidget::pane {
    border: 1px solid #555;
    border-radius: 4px;
    top: -1px;
    background: #2D2D2D;
}
QTabBar::tab {
    background: #1A1A1A;
    color: #E6E6E6;
    padding: 6px 14px;
    border: 1px solid #555;
    border-bottom: none;
    border-top-left-radius: 4px;
    border-top-right-radius: 4px;
    margin-right: 2px;
    font-size: @FS@px;
}
QTabBar::tab:selected { background: #2D2D2D; color: #FFA600; }
QTabBar::tab:hover    { color: #FFB833; }
)").replace(QLatin1String("@FS@"), QString::number(fontPx));
}

// ── Reorderable click buttons ────────────────────────────────────────────────
// Canonical/default toolbar order.  Right Double / Right Drag are included so
// the order model is complete and MainWindow can still lay them out if ever
// re-enabled in code, but they are read-only placeholders (kept off) and are
// not shown in the settings reorder list.
const QVector<ClickButtonDesc>& clickButtonDescs()
{
    static const QVector<ClickButtonDesc> v = {
        { "no_click",      &AppSettings::showNoClick     },
        { "left_click",    &AppSettings::showLeftClick   },
        { "left_double",   &AppSettings::showLeftDouble  },
        { "left_drag",     &AppSettings::showLeftDrag    },
        { "right_click",   &AppSettings::showRightClick  },
        { "right_double",  &AppSettings::showRightDouble },
        { "right_drag",    &AppSettings::showRightDrag   },
        { "middle_click",  &AppSettings::showMiddleClick },
        { "middle_double", &AppSettings::showMiddleDouble},
        { "scroll_up",     &AppSettings::showScrollUp       },
        { "scroll_down",   &AppSettings::showScrollDown     },
        { "scroll_horiz",  &AppSettings::showScrollHoriz    },
        { "ctrl",          &AppSettings::showModCtrl        },
        { "alt",           &AppSettings::showModAlt         },
        { "shift",         &AppSettings::showModShift       },
        { "dwell_active",  &AppSettings::showDwellActiveBtn },
        { "quit",          &AppSettings::showQuitButton     },
        { "keyboard",      &AppSettings::showKeyboardButton },
    };
    return v;
}

// Number of custom hotkey slots; their reorder ids are "hotkey_0".."hotkey_2".
static constexpr int kHotkeyCount = 3;

int hotkeyIndexForId(const QString& id)
{
    if (!id.startsWith(QLatin1String("hotkey_"))) return -1;
    bool ok = false;
    const int idx = id.mid(7).toInt(&ok);
    return (ok && idx >= 0 && idx < kHotkeyCount) ? idx : -1;
}

// Full canonical id set / default order: the bool-backed buttons, then the
// hotkey slots — but Dwell Active and Quit are pushed to the very bottom so by
// default they sit at the end of the list (below the hotkeys).
static QStringList canonicalButtonIds()
{
    QStringList ids;
    for (const auto& d : clickButtonDescs()) {
        const QString id = QLatin1String(d.id);
        if (id == QLatin1String("dwell_active") || id == QLatin1String("quit")
            || id == QLatin1String("keyboard"))
            continue;   // appended at the very end below
        ids << id;
    }
    for (int i = 0; i < kHotkeyCount; ++i)
        ids << QStringLiteral("hotkey_%1").arg(i);
    ids << QStringLiteral("dwell_active") << QStringLiteral("keyboard")
        << QStringLiteral("quit");
    return ids;
}

QStringList orderedClickButtonIds(const AppSettings& s)
{
    const QStringList canon = canonicalButtonIds();
    QStringList result;
    // Saved order first (recognised ids, no duplicates).
    for (const QString& id : s.buttonOrder)
        if (canon.contains(id) && !result.contains(id))
            result << id;
    // Then any canonical ids the saved order didn't cover (new/unsaved buttons).
    for (const QString& id : canon)
        if (!result.contains(id))
            result << id;
    return result;
}

// The AppSettings visibility flag controlled by a bool-backed id (nullptr for an
// unknown or hotkey-backed id).
static bool AppSettings::* showMemberForId(const QString& id)
{
    for (const auto& d : clickButtonDescs())
        if (id == QLatin1String(d.id))
            return d.show;
    return nullptr;
}

// Whether a reorder-list id is currently enabled/visible.  Handles both the
// bool-backed buttons and the hotkey slots (hotkeys[i].enabled).
static bool buttonEnabled(const AppSettings& s, const QString& id)
{
    const int hk = hotkeyIndexForId(id);
    if (hk >= 0) return s.hotkeys[hk].enabled;
    if (bool AppSettings::* memb = showMemberForId(id)) return s.*memb;
    return false;
}

static void setButtonEnabled(AppSettings& s, const QString& id, bool on)
{
    const int hk = hotkeyIndexForId(id);
    if (hk >= 0) { s.hotkeys[hk].enabled = on; return; }
    if (bool AppSettings::* memb = showMemberForId(id)) s.*memb = on;
}

// ── Sensitivity Tester ────────────────────────────────────────────────────────

class CrosshairWidget : public QWidget
{
public:
    explicit CrosshairWidget(QWidget* parent = nullptr) : QWidget(parent)
    {
        setFixedSize(120, 120);
    }

    void setHighlighted(bool h) { if (m_hl != h) { m_hl = h; update(); } }

    QPoint centerInScreen() const
    {
        return mapToGlobal(QPoint(width() / 2, height() / 2));
    }

protected:
    void paintEvent(QPaintEvent*) override
    {
        QPainter p(this);
        p.setRenderHint(QPainter::Antialiasing);
        p.fillRect(rect(), QColor(0x1A, 0x1A, 0x1A));

        p.setPen(QPen(QColor("#555555"), 1));
        p.drawRect(rect().adjusted(0, 0, -1, -1));

        int cx = width() / 2, cy = height() / 2;
        QColor col = m_hl ? QColor("#FFD000") : QColor("#FFA600");

        p.setPen(QPen(col, 1));
        p.drawLine(0, cy, width() - 1, cy);
        p.drawLine(cx, 0, cx, height() - 1);

        p.setBrush(Qt::NoBrush);
        p.drawEllipse(QPoint(cx, cy), 8, 8);

        p.setPen(Qt::NoPen);
        p.setBrush(col);
        p.drawEllipse(QPoint(cx, cy), 2, 2);
    }

private:
    bool m_hl = false;
};

class SensitivityTesterDialog : public QDialog
{
    Q_OBJECT
public:
    explicit SensitivityTesterDialog(QWidget* parent = nullptr);

signals:
    void sensitivityChosen(int px);

private slots:
    void onStart();
    void onPoll();

private:
    void finishMeasurement();

    enum class Phase { Idle, Waiting, Measuring, Done };

    CrosshairWidget* m_crosshair;
    QLabel*          m_infoLbl;
    QProgressBar*    m_bar;
    QLabel*          m_resultLbl;
    QPushButton*     m_startBtn;
    QTimer           m_timer;

    Phase  m_phase     = Phase::Idle;
    QPoint m_lastPos;
    double m_sumDelta  = 0.0;
    int    m_samples   = 0;
    int    m_elapsedMs = 0;

    static constexpr int k_durationMs = 8000;
    static constexpr int k_hoverPx   = 30;
    static constexpr int k_pollMs    = 50;
};

SensitivityTesterDialog::SensitivityTesterDialog(QWidget* parent)
    : QDialog(parent)
{
    setWindowTitle(tr("Sensitivity Tester"));
    setModal(true);
    setStyleSheet(buildStyle(kBaseFontPx));
    setFixedWidth(280);

    auto* root = new QVBoxLayout(this);
    root->setSpacing(10);
    root->setContentsMargins(16, 16, 16, 16);

    m_infoLbl = new QLabel(
        tr("Click Start, then move your mouse over\nthe crosshairs and keep it still."));
    m_infoLbl->setAlignment(Qt::AlignCenter);
    m_infoLbl->setWordWrap(true);
    root->addWidget(m_infoLbl);

    auto* crossRow = new QHBoxLayout;
    m_crosshair = new CrosshairWidget;
    crossRow->addStretch();
    crossRow->addWidget(m_crosshair);
    crossRow->addStretch();
    root->addLayout(crossRow);

    m_bar = new QProgressBar;
    m_bar->setRange(0, 100);
    m_bar->setValue(0);
    m_bar->setTextVisible(false);
    m_bar->setFixedHeight(8);
    // Unlabelled bar: the surrounding text explains the exercise but nothing
    // names the bar itself, and its value is the whole point of the dialog.
    a11y::setName(m_bar, tr("Measured cursor movement"));
    m_bar->setStyleSheet(
        "QProgressBar{background:#1A1A1A;border:1px solid #555;border-radius:3px;}"
        "QProgressBar::chunk{background:#FFA600;border-radius:2px;}");
    root->addWidget(m_bar);

    m_resultLbl = new QLabel;
    m_resultLbl->setAlignment(Qt::AlignCenter);
    m_resultLbl->setStyleSheet("color:#FFA600; font-weight:bold;");
    m_resultLbl->hide();
    root->addWidget(m_resultLbl);

    auto* btnRow = new QHBoxLayout;
    m_startBtn   = new QPushButton(tr("Start"));
    auto* closeBtn = new QPushButton(tr("Close"));
    closeBtn->setProperty("flat", true);
    btnRow->addStretch();
    btnRow->addWidget(m_startBtn);
    btnRow->addWidget(closeBtn);
    btnRow->addStretch();
    root->addLayout(btnRow);

    connect(m_startBtn, &QPushButton::clicked, this, &SensitivityTesterDialog::onStart);
    connect(closeBtn,   &QPushButton::clicked, this, &QDialog::accept);

    m_timer.setInterval(k_pollMs);
    connect(&m_timer, &QTimer::timeout, this, &SensitivityTesterDialog::onPoll);
}

void SensitivityTesterDialog::onStart()
{
    m_phase     = Phase::Waiting;
    m_sumDelta  = 0.0;
    m_samples   = 0;
    m_elapsedMs = 0;
    m_lastPos   = QCursor::pos();

    m_startBtn->setEnabled(false);
    m_resultLbl->hide();
    m_bar->setValue(0);
    m_infoLbl->setText(tr("Move your mouse over the crosshairs\nand keep it still."));
    m_timer.start();
}

void SensitivityTesterDialog::onPoll()
{
    QPoint cur    = QCursor::pos();
    QPoint center = m_crosshair->centerInScreen();
    double dist   = std::hypot(double(cur.x() - center.x()),
                               double(cur.y() - center.y()));
    bool nearCenter = dist <= k_hoverPx;
    m_crosshair->setHighlighted(nearCenter);

    if (m_phase == Phase::Waiting) {
        if (nearCenter) {
            m_phase     = Phase::Measuring;
            m_lastPos   = cur;
            m_sumDelta  = 0.0;
            m_samples   = 0;
            m_elapsedMs = 0;
            m_infoLbl->setText(tr("Measuring — keep your mouse still…"));
        }
    } else if (m_phase == Phase::Measuring) {
        double d = std::hypot(double(cur.x() - m_lastPos.x()),
                              double(cur.y() - m_lastPos.y()));
        m_sumDelta  += d;
        m_samples++;
        m_lastPos    = cur;
        m_elapsedMs += k_pollMs;
        m_bar->setValue(m_elapsedMs * 100 / k_durationMs);
        if (m_elapsedMs >= k_durationMs)
            finishMeasurement();
    }
}

void SensitivityTesterDialog::finishMeasurement()
{
    m_timer.stop();
    m_phase = Phase::Done;
    m_crosshair->setHighlighted(false);
    m_bar->setValue(100);

    double avg     = m_samples > 0 ? m_sumDelta / m_samples : 1.0;
    // Recommend ~2x what the earlier factor produced: measured jitter alone was
    // running too low to filter real-world cursor tremor, so scale it up.
    int recommended = qBound(1, static_cast<int>(std::ceil(avg * 4.0)), 100);

    m_resultLbl->setText(tr("Sensitivity set to %1 px").arg(recommended));
    m_resultLbl->show();
    m_startBtn->setText(tr("Retest"));
    m_startBtn->setEnabled(true);

    emit sensitivityChosen(recommended);
}

// ─────────────────────────────────────────────────────────────────────────────

SettingsDialog::SettingsDialog(const AppSettings& current,
                               QTranslator* appTranslator,
                               QWidget* parent)
    : QDialog(parent), m_settings(current), m_appTranslator(appTranslator)
{
    setWindowTitle(tr("TrackClick — Settings"));
    setModal(true);
    setStyleSheet(buildStyle(kBaseFontPx));
    buildUi();
    loadFrom(current);

    // Seize sole control of the qApp translator for the dialog's lifetime.
    // Removing MainWindow's translator here ensures that when the user picks
    // English the preview system can install nothing and tr() correctly falls
    // through to source strings — even if the app was previously in another
    // language.  Screen repaints are deferred until the event loop runs, so
    // the two rapid LanguageChange events below produce no visible flicker.
    if (m_appTranslator)
        qApp->removeTranslator(m_appTranslator);

    // Warm up the preview for the starting language so the dialog reflects
    // the current language immediately.  Connected AFTER this call so the
    // combo's initial value doesn't fire a duplicate preview.
    applyLanguagePreview(current.language);

    connect(m_cmbLanguage, &QComboBox::currentIndexChanged, this, [this](){
        applyLanguagePreview(m_cmbLanguage->currentData().toString());
    });

    connect(m_buttons, &QDialogButtonBox::accepted, this, [this](){
        m_settings = readUi();
        accept();
    });
    connect(m_buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
    connect(m_resetBtn, &QPushButton::clicked, this, [this](){
        // "Reset to Defaults" covers appearance and behaviour.  Carry the privacy
        // opt-out across untouched: silently re-enabling reporting for someone who
        // turned it off would be a choice they never made.
        AppSettings defaults;
        defaults.usageReporting = m_chkUsageReporting->isChecked();
        loadFrom(defaults);
    });

    // ── Live input-level meter (calibration) ──────────────────
    m_meterTimer.setInterval(40);
    connect(&m_meterTimer, &QTimer::timeout, this, [this](){
        m_meterTarget *= 0.82;   // smooth decay so the bar falls back gently
        m_audioMeter->setValue(static_cast<int>(qBound(0.0, m_meterTarget, 1.0) * 100));
    });
#ifdef HAVE_MULTIMEDIA
    m_meterListener = new AudioClickListener(this);
    connect(m_meterListener, &AudioClickListener::level, this, [this](double l){
        if (l > m_meterTarget) m_meterTarget = l;   // instant rise, timed fall
    });
    // Only open the microphone while the Audio Click tab (index 3) is showing.
    connect(m_tabs, &QTabWidget::currentChanged, this, [this](int idx){
        if (idx == 3) startAudioMeter();
        else          stopAudioMeter();
    });
#endif
}

// ── Language preview ──────────────────────────────────────────────────────────

void SettingsDialog::applyLanguagePreview(const QString& lang)
{
    // Swap only the preview translator — do NOT restore m_appTranslator here.
    // m_appTranslator stays out of qApp for the entire dialog lifetime so that
    // choosing English (no preview translator) correctly shows English rather
    // than falling back to the previously-active language.
    if (m_previewTranslator) {
        qApp->removeTranslator(m_previewTranslator);
        delete m_previewTranslator;
        m_previewTranslator = nullptr;
    }

    if (lang != "en") {
        m_previewTranslator = loadBestTranslator(lang, this);
        if (m_previewTranslator)
            qApp->installTranslator(m_previewTranslator);
    }
    // Qt automatically broadcasts QEvent::LanguageChange to this dialog when
    // the translator list changes, which triggers changeEvent → retranslateUi().
}

void SettingsDialog::cleanupPreviewTranslator()
{
    if (m_previewTranslator) {
        qApp->removeTranslator(m_previewTranslator);
        delete m_previewTranslator;
        m_previewTranslator = nullptr;
    }
    // Hand the app translator back to qApp so that after the dialog closes
    // the main window reverts to its previous language (on Cancel) or
    // MainWindow::installLanguage can remove and replace it (on Accept).
    if (m_appTranslator) {
        qApp->installTranslator(m_appTranslator);
        m_appTranslator = nullptr; // ownership stays with MainWindow
    }
}

void SettingsDialog::done(int result)
{
    // Always clean up before closing so that MainWindow::installLanguage()
    // (called on Accept) starts with only its own translator installed, and
    // on Cancel the app reverts to whatever translator was active before the
    // dialog opened.
    cleanupPreviewTranslator();
    stopAudioMeter();   // release the microphone when the dialog closes
    QDialog::done(result);
}

// ── Retranslation ─────────────────────────────────────────────────────────────

void SettingsDialog::changeEvent(QEvent* e)
{
    QDialog::changeEvent(e);
    if (e->type() == QEvent::LanguageChange)
        retranslateUi();
}

void SettingsDialog::retranslateUi()
{
    setWindowTitle(tr("TrackClick — Settings"));

    m_tabs->setTabText(0, tr("Dwell Clicking"));
    m_lblDwellTime->setText(tr("Dwell time:"));
    m_lblSensitivity->setText(tr("Sensitivity:"));
    m_btnSensTester->setText(tr("Sensitivity Tester…"));
    m_lblHoverSelect->setText(tr("Hover to switch:"));
    m_hoverSelectPct->setToolTip(tr("How long a toolbar button must be hovered before the "
                                    "selection switches to it, as a percentage of the dwell time."));
    m_lblScrollRepeat->setText(tr("Scroll repeat:"));
    m_lblRepeatMode->setText(tr("Repeat click:"));
    m_lblReturnToLeft->setText(tr("Return to left click after click:"));
#ifdef Q_OS_MAC
    m_lblPermissions->setText(tr("Permissions:"));
    m_btnAccessibility->setText(tr("Open Accessibility Settings…"));
#endif

    m_tabs->setTabText(1, tr("Buttons"));
    m_lblVisibleButtons->setText(tr("Visible Buttons (check to show, Move Up/Down to reorder)"));
    m_btnMoveUp->setText(tr("Move Up"));
    m_btnMoveDown->setText(tr("Move Down"));
    for (int i = 0; i < m_btnOrderList->count(); ++i) {
        QListWidgetItem* it = m_btnOrderList->item(i);
        it->setText(clickButtonLabel(it->data(Qt::UserRole).toString()));
    }

    m_lblCustomHotkeys->setText(tr("Custom Hotkeys"));
    for (int i = 0; i < 3; ++i) {
        m_lblHotkey[i]->setText(tr("Hotkey %1").arg(i + 1));
        m_edtHotkeyLabel[i]->setPlaceholderText(tr("Label (optional)"));
    }

    m_tabs->setTabText(2, tr("Window"));
    m_grpWinBehavior->setTitle(tr("Window Behavior"));
    m_grpButtonControls->setTitle(tr("Button Controls"));
    m_grpFeedback->setTitle(tr("Feedback"));
    m_lblEdgeLock->setText(tr("Lock to screen edge:"));
    m_cmbEdgeLock->setItemText(0, tr("None"));
    m_cmbEdgeLock->setItemText(1, tr("Left edge"));
    m_cmbEdgeLock->setItemText(2, tr("Right edge"));
    m_chkEdgeHide->setText(tr("Slide off screen when idle"));
    m_chkAlwaysOnTop->setText(tr("Always on top"));
    m_chkStartMinimized->setText(tr("Start minimized to tray"));
    m_chkXMinimizesApp->setText(tr("Top X minimizes app"));
    m_chkLaunchOnStartup->setText(tr("Launch on system startup (Windows)"));
    m_chkMinimalWidth->setText(tr("Minimal width"));
    m_lblMinimalWidthPx->setText(tr("Width limit (px):"));
    m_spinMinimalWidthPx->setSpecialValueText(tr("Auto (fit content)"));
    m_chkAudio->setText(tr("Audio feedback on click"));
    m_chkClickIndicator->setText(tr("Show click indicator ring (Windows)"));
    m_chkShowLabels->setText(tr("Show button labels"));
    m_chkLargeButtons->setText(tr("Large buttons"));
    m_lblOpacity->setText(tr("Opacity:"));
    m_lblBtnLayout->setText(tr("Button layout:"));
    m_cmbLayout->setItemText(0, tr("Rectangle (grid)"));
    m_cmbLayout->setItemText(1, tr("Horizontal (one row)"));
    m_cmbLayout->setItemText(2, tr("Vertical (one column)"));
    m_cmbLayout->setItemText(3, tr("Vertical (two columns)"));
    m_lblLanguage->setText(tr("Language:"));
    m_lblZoom->setText(tr("Zoom:"));
    m_okBtn->setText(tr("OK"));
    m_cancelBtn->setText(tr("Cancel"));
    m_resetBtn->setText(tr("Reset to Defaults"));
    m_btnOnScreenKbd->setText(tr("Open On-Screen Keyboard"));

    m_tabs->setTabText(3, tr("Audio Click"));
    m_chkAudioClick->setText(tr("Trigger the selected action with a loud sound"));
    m_lblAudioClickInfo->setText(audioClickInfoText());
    m_lblAudioDevice->setText(tr("Input device:"));
    m_cmbAudioDevice->setItemText(0, tr("System default"));
    m_lblAudioThreshold->setText(tr("Loudness threshold:"));
    m_lblAudioMeter->setText(tr("Input level:"));

    m_tabs->setTabText(4, tr("Diagnostics"));
    m_lblDiagIntro->setText(
        tr("If clicking isn't working, this information helps pin down why."));
    m_btnCopyDiag->setText(tr("Copy diagnostics"));
    m_lblSelfTestHelp->setText(
        tr("Click self-test: TrackClick moves the pointer to the target below and "
           "injects a real click. If the target lights up green, click injection "
           "is working end-to-end."));
    m_btnSelfTest->setText(tr("Run click self-test"));
    m_diagTarget->setText(tr("Target"));
    m_lblLogHeading->setText(tr("Log file"));
    m_lblLogHelp->setText(logHelpText());
    m_chkLogging->setText(tr("Write a log file"));
    m_btnOpenLogFolder->setText(tr("Open log folder"));
    m_btnClearLog->setText(tr("Clear log"));
    refreshLogStatus();   // carries the translatable "empty" marker
    m_lblProfilesHeading->setText(tr("Profiles and backup"));
    m_lblProfilesHelp->setText(profilesHelpText());
    m_lblProfile->setText(tr("Profile:"));
    m_btnProfileLoad->setText(tr("Load"));
    m_btnProfileSave->setText(tr("Save as…"));
    m_btnProfileDelete->setText(tr("Delete"));
    m_btnExportSettings->setText(tr("Export to file…"));
    m_btnImportSettings->setText(tr("Import from file…"));
    // Re-render the "(no saved profiles)" placeholder in the new language.
    // Any status message stays as-is: it reports a past action, and there is
    // nothing sensible to re-render it from.
    refreshProfileList(m_cmbProfiles->isEnabled() ? m_cmbProfiles->currentText()
                                                  : QString());
    m_chkUsageReporting->setText(tr("Send anonymous usage statistics"));
    m_lblUsageReporting->setText(usageReportingInfoText());
    refreshDiagnostics();

    // Last: the accessible names are derived from the label texts set above.
    syncAccessibleNames();
}

// ── Profiles / export-import ─────────────────────────────────────────────────
// These live on the Diagnostics tab rather than beside OK/Cancel because they
// are occasional operations — troubleshooting, or matching one machine to
// another — not part of the ordinary edit-and-accept flow.

// The QSettings pair MainWindow persists to; profiles ride along in it.
static QSettings profileStore()
{
    return QSettings(QStringLiteral("TrackClick"), QStringLiteral("TrackClick"));
}

QString SettingsDialog::profilesHelpText() const
{
    // Kept short on purpose: the Diagnostics tab is the tallest one, and every
    // wrapped line here raises the whole dialog's minimum height.
    return tr("Name a copy of these settings, or move them between computers as a "
              "file. Loading only fills in this window; nothing is applied until "
              "you press OK.");
}

QString SettingsDialog::logHelpText() const
{
    // Short for the same reason as profilesHelpText(): this is the tallest tab.
    // Says where it goes and that it stays there — the app already looks
    // suspicious enough (INTERNAL §1) without an unexplained file appearing.
    // Off by default, so the text has to teach the order of operations — a user
    // who copies diagnostics first gets an empty log and no hint why.
    return tr("Off by default. Switch it on, reproduce the problem, then use Copy "
              "diagnostics. Kept on this computer and never sent anywhere; nothing "
              "you type is recorded.");
}

void SettingsDialog::buildProfilesSection(QVBoxLayout* v)
{
    auto* sep = new QFrame;
    sep->setFrameShape(QFrame::HLine);
    sep->setStyleSheet("QFrame { color:#555; }");
    v->addWidget(sep);

    m_lblProfilesHeading = new QLabel(tr("Profiles and backup"));
    m_lblProfilesHeading->setStyleSheet("font-weight:bold;");
    v->addWidget(m_lblProfilesHeading);

    m_lblProfilesHelp = new QLabel(profilesHelpText());
    m_lblProfilesHelp->setWordWrap(true);
    m_lblProfilesHelp->setStyleSheet("color:#AAA;");
    // Wrapped labels report a single-line width hint, which would widen the
    // whole dialog; let it wrap into the width the tab already has instead.
    m_lblProfilesHelp->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum);
    v->addWidget(m_lblProfilesHelp);

    auto* profileRow = new QHBoxLayout;
    m_lblProfile = new QLabel(tr("Profile:"));
    m_cmbProfiles = new QComboBox;
    m_cmbProfiles->setMinimumWidth(140);
    m_cmbProfiles->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
    m_btnProfileLoad   = new QPushButton(tr("Load"));
    m_btnProfileSave   = new QPushButton(tr("Save as…"));
    m_btnProfileDelete = new QPushButton(tr("Delete"));
    profileRow->addWidget(m_lblProfile);
    profileRow->addWidget(m_cmbProfiles, 1);
    profileRow->addWidget(m_btnProfileLoad);
    profileRow->addWidget(m_btnProfileSave);
    profileRow->addWidget(m_btnProfileDelete);
    v->addLayout(profileRow);

    auto* fileRow = new QHBoxLayout;
    m_btnExportSettings = new QPushButton(tr("Export to file…"));
    m_btnImportSettings = new QPushButton(tr("Import from file…"));
    fileRow->addWidget(m_btnExportSettings);
    fileRow->addWidget(m_btnImportSettings);
    fileRow->addStretch(1);
    v->addLayout(fileRow);

    // Single line, not wrapped: it reports file paths, and letting it wrap would
    // make the dialog's height depend on how long a path the user happened to
    // pick.  Long text is elided by the style instead.
    m_lblProfileStatus = new QLabel;
    m_lblProfileStatus->setStyleSheet("color:#AAA;");
    m_lblProfileStatus->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
    v->addWidget(m_lblProfileStatus);

    connect(m_btnProfileSave,    &QPushButton::clicked, this, &SettingsDialog::onSaveProfile);
    connect(m_btnProfileLoad,    &QPushButton::clicked, this, &SettingsDialog::onLoadProfile);
    connect(m_btnProfileDelete,  &QPushButton::clicked, this, &SettingsDialog::onDeleteProfile);
    connect(m_btnExportSettings, &QPushButton::clicked, this, &SettingsDialog::onExportSettings);
    connect(m_btnImportSettings, &QPushButton::clicked, this, &SettingsDialog::onImportSettings);

    refreshProfileList();
}

void SettingsDialog::refreshProfileList(const QString& select)
{
    QSettings store = profileStore();
    const QStringList names = settingsProfileNames(store);

    m_cmbProfiles->clear();
    m_cmbProfiles->addItems(names);
    if (!select.isEmpty()) {
        const int idx = m_cmbProfiles->findText(select);
        if (idx >= 0) m_cmbProfiles->setCurrentIndex(idx);
    }

    // Nothing saved yet: keep the combo visible (so the feature is discoverable)
    // but make clear there is nothing to act on.
    const bool any = !names.isEmpty();
    m_cmbProfiles->setEnabled(any);
    m_btnProfileLoad->setEnabled(any);
    m_btnProfileDelete->setEnabled(any);
    if (!any)
        m_cmbProfiles->addItem(tr("(no saved profiles)"));
}

void SettingsDialog::onSaveProfile()
{
    const QStringList existing = [&]{ QSettings s = profileStore();
                                      return settingsProfileNames(s); }();

    bool ok = false;
    const QString name = QInputDialog::getText(
        this, tr("Save profile"), tr("Profile name:"), QLineEdit::Normal,
        m_cmbProfiles->isEnabled() ? m_cmbProfiles->currentText() : QString(), &ok)
        .trimmed();
    if (!ok || name.isEmpty())
        return;

    if (existing.contains(name)
        && QMessageBox::question(this, tr("Save profile"),
               tr("A profile named \"%1\" already exists. Replace it?").arg(name))
           != QMessageBox::Yes)
        return;

    QSettings store = profileStore();
    saveSettingsProfile(store, name, readUi());
    store.sync();
    refreshProfileList(name);
    m_lblProfileStatus->setText(tr("Saved the current settings as \"%1\".").arg(name));
}

void SettingsDialog::onLoadProfile()
{
    const QString name = m_cmbProfiles->currentText();
    if (name.isEmpty() || !m_cmbProfiles->isEnabled())
        return;

    QSettings store = profileStore();
    AppSettings loaded;
    // Anything the profile does not carry keeps what is on screen right now.
    if (!loadSettingsProfile(store, name, readUi(), loaded)) {
        m_lblProfileStatus->setText(tr("Could not read the profile \"%1\".").arg(name));
        return;
    }
    applyImported(loaded, tr("Loaded \"%1\". Press OK to apply.").arg(name));
}

void SettingsDialog::onDeleteProfile()
{
    const QString name = m_cmbProfiles->currentText();
    if (name.isEmpty() || !m_cmbProfiles->isEnabled())
        return;

    if (QMessageBox::question(this, tr("Delete profile"),
            tr("Delete the profile \"%1\"? This cannot be undone.").arg(name))
        != QMessageBox::Yes)
        return;

    QSettings store = profileStore();
    deleteSettingsProfile(store, name);
    store.sync();
    refreshProfileList();
    m_lblProfileStatus->setText(tr("Deleted the profile \"%1\".").arg(name));
}

void SettingsDialog::onExportSettings()
{
    QString path = QFileDialog::getSaveFileName(
        this, tr("Export settings"),
        QDir(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation))
            .filePath(QStringLiteral("trackclick-settings.json")),
        tr("TrackClick settings (*.json)"));
    if (path.isEmpty())
        return;
    if (!path.endsWith(QLatin1String(".json"), Qt::CaseInsensitive))
        path += QLatin1String(".json");

    QFile f(path);
    if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        QMessageBox::warning(this, tr("Export settings"),
            tr("Could not write to %1.\n\n%2").arg(QDir::toNativeSeparators(path),
                                                   f.errorString()));
        return;
    }
    // Indented rather than compact: these files get opened in a text editor and
    // pasted into bug reports.
    const QByteArray json = QJsonDocument(settingsToJson(readUi())).toJson();
    if (f.write(json) != json.size()) {
        QMessageBox::warning(this, tr("Export settings"),
            tr("Could not write to %1.\n\n%2").arg(QDir::toNativeSeparators(path),
                                                   f.errorString()));
        return;
    }
    f.close();
    m_lblProfileStatus->setText(tr("Exported to %1.").arg(QDir::toNativeSeparators(path)));
}

void SettingsDialog::onImportSettings()
{
    const QString path = QFileDialog::getOpenFileName(
        this, tr("Import settings"),
        QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation),
        tr("TrackClick settings (*.json)"));
    if (path.isEmpty())
        return;

    QFile f(path);
    if (!f.open(QIODevice::ReadOnly)) {
        QMessageBox::warning(this, tr("Import settings"),
            tr("Could not read %1.\n\n%2").arg(QDir::toNativeSeparators(path),
                                               f.errorString()));
        return;
    }
    QJsonParseError err {};
    const QJsonDocument doc = QJsonDocument::fromJson(f.readAll(), &err);
    f.close();

    if (err.error != QJsonParseError::NoError || !doc.isObject()) {
        QMessageBox::warning(this, tr("Import settings"),
            tr("%1 is not a valid settings file.").arg(QDir::toNativeSeparators(path)));
        return;
    }
    // Reject an unrelated .json outright rather than "importing" it as a set of
    // defaults, which would silently wipe the user's configuration.
    if (!isSettingsJson(doc.object())) {
        QMessageBox::warning(this, tr("Import settings"),
            tr("%1 is not a TrackClick settings file, or it was written by a "
               "newer version.").arg(QDir::toNativeSeparators(path)));
        return;
    }

    applyImported(settingsFromJson(doc.object(), readUi()),
                  tr("Imported from %1. Press OK to apply.")
                      .arg(QDir::toNativeSeparators(path)));
}

void SettingsDialog::applyImported(const AppSettings& s, const QString& message)
{
    // loadFrom() drives every control, including the language selector, so the
    // dialog re-renders in the incoming language just as if it had been picked
    // by hand.  Nothing reaches MainWindow until the user accepts.
    loadFrom(s);
    m_lblProfileStatus->setText(message);
}

QString SettingsDialog::usageReportingInfoText() const
{
    return tr("Counts app launches. A report carries the operating system, the app "
              "version, whether clicks are triggered by dwell or by sound, and a "
              "scrambled id that tells repeat launches apart without identifying "
              "you or this computer, nothing else.");
}

QString SettingsDialog::audioClickInfoText() const
{
#ifdef HAVE_MULTIMEDIA
    return tr("When enabled, the selected action fires when the microphone hears "
              "a loud sound (such as a clap or a pop) instead of waiting for the "
              "dwell timer. Turn on Dwell Active to start listening. Any loud "
              "noise triggers the action — speech is not interpreted.");
#else
    return tr("Audio support is not available in this build, so audio click "
              "cannot be used.");
#endif
}

void SettingsDialog::startAudioMeter()
{
#ifdef HAVE_MULTIMEDIA
    if (!m_meterListener) return;
    if (!m_meterListener->isRunning()) {
        // Capture from whichever device is selected in the picker.
        m_meterListener->setPreferredDeviceId(m_cmbAudioDevice->currentData().toString());
        m_meterListener->start();   // harmless if there is no input device
    }
    m_meterTimer.start();
#endif
}

void SettingsDialog::stopAudioMeter()
{
#ifdef HAVE_MULTIMEDIA
    m_meterTimer.stop();
    if (m_meterListener) m_meterListener->stop();
#endif
    m_meterTarget = 0.0;
    if (m_audioMeter) m_audioMeter->setValue(0);
}

// ── UI construction ───────────────────────────────────────────────────────────

// Renders a settings checkbox read-only: unchecked, disabled, and dimmed so it
// clearly can't be toggled. Kept for options we lock off but leave visible
// (Right Double, Right Drag, Top X minimizes app) so they can be re-enabled in
// code later.
//
// [[maybe_unused]] deliberately: it currently has no call sites — those options
// are now hidden rather than shown-and-disabled — but it is retained as the
// ready-made affordance for re-enabling them, which is why it is not deleted.
[[maybe_unused]] static void makeCheckboxReadOnly(QCheckBox* c)
{
    c->setChecked(false);
    c->setEnabled(false);
    auto* fade = new QGraphicsOpacityEffect(c);
    fade->setOpacity(0.4);   // dim to signal the disabled/read-only state
    c->setGraphicsEffect(fade);
}

void SettingsDialog::buildUi()
{
    auto* root = new QVBoxLayout(this);
    root->setSpacing(10);
    root->setContentsMargins(14, 14, 14, 14);

    // ── Brand header ──────────────────────────────────────────
    auto* header = new QWidget;
    header->setObjectName("appHeader");
    header->setStyleSheet(
        "QWidget#appHeader { background: #1A1A1A; border-radius: 6px; }");

    auto* hLay = new QHBoxLayout(header);
    hLay->setContentsMargins(14, 10, 14, 10);
    hLay->setSpacing(14);

    // OptiTrack logo rendered from embedded SVG
    QSvgRenderer svgRend(QString(":/icons/optitrack_logo.svg"));
    const int logoH = 30;
    const int logoW = qRound(svgRend.defaultSize().width()
                             * logoH / double(svgRend.defaultSize().height()));
    QPixmap logoPx(logoW, logoH);
    logoPx.fill(Qt::transparent);
    QPainter logoPainter(&logoPx);
    svgRend.render(&logoPainter);

    auto* logoLbl = new QLabel;
    logoLbl->setPixmap(logoPx);
    logoLbl->setStyleSheet("background: transparent;");
    hLay->addWidget(logoLbl);

    // Vertical divider
    auto* vSep = new QFrame;
    vSep->setFrameShape(QFrame::VLine);
    vSep->setStyleSheet("color: #444;");
    hLay->addWidget(vSep);

    // App name + version
    auto* nameLay = new QVBoxLayout;
    nameLay->setSpacing(1);
    auto* appNameLbl = new QLabel("TrackClick");
    appNameLbl->setStyleSheet(
        "color: #FFFFFF; font-size: 16px; font-weight: bold; background: transparent;");
    auto* versionLbl = new QLabel(QStringLiteral("Version ") + displayVersion());
    versionLbl->setStyleSheet(
        "color: #666666; font-size: 11px; background: transparent;");
    nameLay->addWidget(appNameLbl);
    nameLay->addWidget(versionLbl);
    hLay->addLayout(nameLay);
    hLay->addStretch(1);

    root->addWidget(header);

    // ── Language selector ─────────────────────────────────────
    // Placed above the tab widget (not inside the Window tab) so the language
    // can be changed no matter which tab is open.  Native-script names are
    // intentionally not translated.
    m_cmbLanguage = new QComboBox;
    m_cmbLanguage->setSizeAdjustPolicy(QComboBox::AdjustToContents);
    m_cmbLanguage->setMinimumWidth(130);
    m_cmbLanguage->addItem("English",   "en");
    m_cmbLanguage->addItem("Čeština",   "cs");
    m_cmbLanguage->addItem("Français",  "fr");
    m_cmbLanguage->addItem("Español",   "es");
    m_cmbLanguage->addItem("中文简体",   "zh_CN");
    m_cmbLanguage->addItem("日本語",     "ja");
    m_cmbLanguage->addItem("한국어",     "ko");
    m_cmbLanguage->addItem("हिन्दी",    "hi");
    m_cmbLanguage->addItem("العربية",   "ar");
    m_cmbLanguage->addItem("বাংলা",     "bn");
    m_cmbLanguage->addItem("Português", "pt");
    m_cmbLanguage->addItem("Русский",   "ru");
    m_cmbLanguage->addItem("اردو",      "ur");
    m_lblLanguage = new QLabel(tr("Language:"));

    // ── Font zoom ─────────────────────────────────────────────
    // Sits next to the language selector so both top-level view options share
    // one row.  The "-"/"+" buttons scale the settings window's own text (see
    // applyFontScale); the value label shows the current percentage.
    m_lblZoom      = new QLabel(tr("Zoom:"));
    m_btnZoomOut   = new QPushButton(QString(QChar(0x2212)));  // U+2212 minus sign
    m_btnZoomIn    = new QPushButton(QStringLiteral("+"));
    m_lblZoomValue = new QLabel;
    m_lblZoomValue->setAlignment(Qt::AlignCenter);
    m_lblZoomValue->setMinimumWidth(44);
    // Dedicated look so the glyphs read clearly: large, bold, accent-orange on a
    // bordered button.  A per-button stylesheet also keeps them a fixed size
    // (they don't grow when the zoom re-applies the dialog stylesheet).
    for (QPushButton* b : { m_btnZoomOut, m_btnZoomIn }) {
        b->setFixedSize(30, 26);
        b->setFocusPolicy(Qt::NoFocus);
        b->setStyleSheet(
            "QPushButton {"
            "  background: #3D3D3D; color: #FFFFFF;"
            "  border: 1px solid #666; border-radius: 4px;"
            "  padding: 0; font-size: 18px; font-weight: bold;"
            "}"
            "QPushButton:hover    { background: #4D4D4D; border-color: #888; }"
            "QPushButton:pressed  { background: #2A2A2A; }"
            "QPushButton:disabled { color: #6A6A6A; border-color: #444; }");
    }
    connect(m_btnZoomOut, &QPushButton::clicked, this, [this]{
        m_fontScale -= kZoomStepPct;
        applyFontScale();
    });
    connect(m_btnZoomIn, &QPushButton::clicked, this, [this]{
        m_fontScale += kZoomStepPct;
        applyFontScale();
    });

    auto* langRow = new QHBoxLayout;
    langRow->addStretch(1);
    langRow->addWidget(m_lblLanguage);
    langRow->addWidget(m_cmbLanguage);
    langRow->addSpacing(18);
    langRow->addWidget(m_lblZoom);
    langRow->addWidget(m_btnZoomOut);
    langRow->addWidget(m_lblZoomValue);
    langRow->addWidget(m_btnZoomIn);
    langRow->addStretch(1);
    root->addLayout(langRow);

    // ── Tabbed sections ───────────────────────────────────────
    // Each former group box becomes a tab page so the dialog shows one section
    // at a time instead of the whole stack at once.  Tab labels carry the
    // section names and are retranslated in retranslateUi().
    m_tabs = new QTabWidget;
    root->addWidget(m_tabs);

    // ── Dwell / AutoMouse ─────────────────────────────────────
    auto* pageDwell = new QWidget;
    auto* fl        = new QFormLayout(pageDwell);
    fl->setSpacing(6);

    m_dwellMs      = new QSpinBox; m_dwellMs->setRange(100, 10000); m_dwellMs->setSuffix(" ms");
    m_sensitivPx   = new QSpinBox; m_sensitivPx->setRange(1, 100);  m_sensitivPx->setSuffix(" px");
    m_hoverSelectPct = new QSpinBox; m_hoverSelectPct->setRange(10, 100); m_hoverSelectPct->setSuffix(" %");
    m_hoverSelectPct->setToolTip(tr("How long a toolbar button must be hovered before the "
                                    "selection switches to it, as a percentage of the dwell time."));
    m_scrollRepeat = new QSpinBox; m_scrollRepeat->setRange(1, 20);

    m_chkRepeatMode = new QCheckBox;
    m_chkReturnToLeft = new QCheckBox;

    m_lblDwellTime    = new QLabel(tr("Dwell time:"));
    m_lblSensitivity  = new QLabel(tr("Sensitivity:"));
    m_lblHoverSelect  = new QLabel(tr("Hover to switch:"));
    m_lblScrollRepeat = new QLabel(tr("Scroll repeat:"));
    m_lblRepeatMode   = new QLabel(tr("Repeat click:"));
    m_lblReturnToLeft = new QLabel(tr("Return to left click after click:"));
    m_btnSensTester = new QPushButton(tr("Sensitivity Tester…"));
    m_btnSensTester->setProperty("flat", true);
    connect(m_btnSensTester, &QPushButton::clicked, this, [this](){
        auto* dlg = new SensitivityTesterDialog(this);
        connect(dlg, &SensitivityTesterDialog::sensitivityChosen,
                this, [this](int px){ m_sensitivPx->setValue(px); });
        dlg->setAttribute(Qt::WA_DeleteOnClose);
        dlg->exec();
    });

    fl->addRow(m_lblDwellTime,    m_dwellMs);
    fl->addRow(m_lblSensitivity,  m_sensitivPx);
    fl->addRow(m_btnSensTester);
    fl->addRow(m_lblHoverSelect,  m_hoverSelectPct);
    fl->addRow(m_lblScrollRepeat, m_scrollRepeat);
    fl->addRow(m_lblReturnToLeft, m_chkReturnToLeft);
    fl->addRow(m_lblRepeatMode,   m_chkRepeatMode);

#ifdef Q_OS_MAC
    m_lblPermissions   = new QLabel(tr("Permissions:"));
    m_btnAccessibility = new QPushButton(tr("Open Accessibility Settings…"));
    m_btnAccessibility->setProperty("flat", true);
    connect(m_btnAccessibility, &QPushButton::clicked, this, [](){
        QDesktopServices::openUrl(QUrl(
            "x-apple.systempreferences:"
            "com.apple.preference.security?Privacy_Accessibility"));
    });
    fl->addRow(m_lblPermissions, m_btnAccessibility);
#endif

    m_tabs->addTab(pageDwell, tr("Dwell Clicking"));

    // ── Button Visibility ─────────────────────────────────────
    auto* pageBtns = new QWidget;
    auto* grid     = new QGridLayout(pageBtns);
    grid->setSpacing(6);

    // Section header for the reorderable click-button list.
    m_lblVisibleButtons = new QLabel(tr("Visible Buttons (check to show, Move Up/Down to reorder)"));
    m_lblVisibleButtons->setStyleSheet(
        "color: #FFA600; font-weight: bold; background: transparent;");
    grid->addWidget(m_lblVisibleButtons, 0, 0, 1, 3);

    // Reorderable, checkable list of the click-action buttons.  Items (order and
    // check state) are added in loadFrom(); the read-only Right Double / Right
    // Drag placeholders are intentionally omitted from this list.
    m_btnOrderList = new QListWidget;
    m_btnOrderList->setSelectionMode(QAbstractItemView::SingleSelection);
    m_btnOrderList->setMinimumHeight(200);
    connect(m_btnOrderList, &QListWidget::currentRowChanged,
            this, [this](int){ updateMoveButtons(); });
    grid->addWidget(m_btnOrderList, 1, 0, 1, 2);

    m_btnMoveUp   = new QPushButton(tr("Move Up"));
    m_btnMoveDown = new QPushButton(tr("Move Down"));
    m_btnMoveUp->setProperty("flat", true);
    m_btnMoveDown->setProperty("flat", true);
    m_btnMoveUp->setFocusPolicy(Qt::NoFocus);
    m_btnMoveDown->setFocusPolicy(Qt::NoFocus);
    connect(m_btnMoveUp,   &QPushButton::clicked, this, [this]{ moveSelectedButton(-1); });
    connect(m_btnMoveDown, &QPushButton::clicked, this, [this]{ moveSelectedButton(+1); });
    auto* moveCol = new QVBoxLayout;
    moveCol->setSpacing(6);
    moveCol->addWidget(m_btnMoveUp);
    moveCol->addWidget(m_btnMoveDown);
    moveCol->addStretch(1);
    auto* moveHolder = new QWidget;
    moveHolder->setLayout(moveCol);
    grid->addWidget(moveHolder, 1, 2, 1, 1, Qt::AlignTop);

    int row = 2;            // rows 0-1 hold the header and the reorder list

    // ── Custom Hotkeys section ────────────────────────────────
    auto* hotkeysSep = new QFrame;
    hotkeysSep->setFrameShape(QFrame::HLine);
    hotkeysSep->setStyleSheet("QFrame { color: #555; }");
    grid->addWidget(hotkeysSep, row++, 0, 1, 3);

    m_lblCustomHotkeys = new QLabel(tr("Custom Hotkeys"));
    m_lblCustomHotkeys->setStyleSheet(
        "color: #FFA600; font-weight: bold; background: transparent;");
    grid->addWidget(m_lblCustomHotkeys, row++, 0, 1, 3);

    // Each row lets the user edit a hotkey's label + key combination.  Turning a
    // hotkey on/off (and ordering it) is done in the reorder list above, so there
    // is no checkbox here — just a static "Hotkey N" label.
    for (int i = 0; i < 3; ++i) {
        m_lblHotkey[i] = new QLabel(tr("Hotkey %1").arg(i + 1));

        m_edtHotkeyLabel[i] = new QLineEdit;
        m_edtHotkeyLabel[i]->setPlaceholderText(tr("Label (optional)"));
        m_edtHotkeyLabel[i]->setToolTip(
            tr("Button label shown on the toolbar. Defaults to the key name if left blank."));

        m_kseHotkey[i] = new QKeySequenceEdit;
        m_kseHotkey[i]->setToolTip(
            tr("Click here and press the desired key combination (e.g. F12, Ctrl+A, Alt+Z)."));
#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
        m_kseHotkey[i]->setMaximumSequenceLength(1);
#endif
        grid->addWidget(m_lblHotkey[i],      row, 0);
        grid->addWidget(m_edtHotkeyLabel[i], row, 1);
        grid->addWidget(m_kseHotkey[i],      row, 2);
        row++;
    }

    grid->setRowStretch(row, 1);

    m_tabs->addTab(pageBtns, tr("Buttons"));

    // ── Window ────────────────────────────────────────────────
    // Grouped into titled sections: Window Behavior, Button Controls, Feedback,
    // with the on-screen keyboard launcher at the very bottom.
    auto* pageWin = new QWidget;
    auto* winCol  = new QVBoxLayout(pageWin);
    winCol->setSpacing(10);

    // Opacity slider + live percentage (placed in the Window Behavior section).
    auto* opRow = new QHBoxLayout;
    m_opacitySlider = new QSlider(Qt::Horizontal);
    m_opacitySlider->setRange(20, 100);
    m_opacityLabel  = new QLabel("100%");
    m_opacityLabel->setFixedWidth(36);
    opRow->addWidget(m_opacitySlider);
    opRow->addWidget(m_opacityLabel);
    connect(m_opacitySlider, &QSlider::valueChanged, this, [this](int v){
        m_opacityLabel->setText(QString::number(v) + "%");
    });

    // ── Section: Window Behavior ──────────────────────────────
    m_grpWinBehavior = new QGroupBox(tr("Window Behavior"));
    auto* behForm = new QFormLayout(m_grpWinBehavior);
    behForm->setSpacing(6);

    m_lblEdgeLock = new QLabel(tr("Lock to screen edge:"));
    m_cmbEdgeLock = new QComboBox;
    m_cmbEdgeLock->setSizeAdjustPolicy(QComboBox::AdjustToContents);
    m_cmbEdgeLock->setMinimumWidth(110);
    m_cmbEdgeLock->addItem(tr("None"),       static_cast<int>(EdgeLock::None));
    m_cmbEdgeLock->addItem(tr("Left edge"),  static_cast<int>(EdgeLock::Left));
    m_cmbEdgeLock->addItem(tr("Right edge"), static_cast<int>(EdgeLock::Right));
    m_chkEdgeHide = new QCheckBox(tr("Slide off screen when idle"));
    connect(m_cmbEdgeLock, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, [this](int idx){ m_chkEdgeHide->setEnabled(idx != 0); });

    m_lblOpacity        = new QLabel(tr("Opacity:"));
    m_chkAlwaysOnTop    = new QCheckBox(tr("Always on top"));
    m_chkStartMinimized = new QCheckBox(tr("Start minimized to tray"));
    m_chkXMinimizesApp  = new QCheckBox(tr("Top X minimizes app"));
    m_chkLaunchOnStartup= new QCheckBox(tr("Launch on system startup (Windows)"));
    m_chkMinimalWidth   = new QCheckBox(tr("Minimal width"));
    m_lblMinimalWidthPx = new QLabel(tr("Width limit (px):"));
    m_spinMinimalWidthPx = new QSpinBox;
    m_spinMinimalWidthPx->setRange(0, 2000);
    m_spinMinimalWidthPx->setSingleStep(10);
    m_spinMinimalWidthPx->setSpecialValueText(tr("Auto (fit content)"));
    m_lblMinimalWidthPx->setEnabled(false);
    m_spinMinimalWidthPx->setEnabled(false);
    connect(m_chkMinimalWidth, &QCheckBox::toggled, this, [this](bool on){
        m_lblMinimalWidthPx->setEnabled(on);
        m_spinMinimalWidthPx->setEnabled(on);
    });

    behForm->addRow(m_lblEdgeLock, m_cmbEdgeLock);
    behForm->addRow(m_chkEdgeHide);
    behForm->addRow(m_lblOpacity, opRow);
    behForm->addRow(m_chkAlwaysOnTop);
    // "Start minimized to tray" and "Top X minimizes app" stay constructed
    // (load/save/retranslate refs) but are hidden from the UI — the top X always
    // quits. To restore the option, add it back to the layout here.
    behForm->addRow(m_chkLaunchOnStartup);
    behForm->addRow(m_chkMinimalWidth);
    behForm->addRow(m_lblMinimalWidthPx, m_spinMinimalWidthPx);
    winCol->addWidget(m_grpWinBehavior);

    // ── Section: Button Controls ──────────────────────────────
    m_grpButtonControls = new QGroupBox(tr("Button Controls"));
    auto* ctrlForm = new QFormLayout(m_grpButtonControls);
    ctrlForm->setSpacing(6);

    // Inverse of iconsOnly: checked = labels shown. Defaults on (iconsOnly off).
    m_chkShowLabels    = new QCheckBox(tr("Show button labels"));
    m_chkLargeButtons  = new QCheckBox(tr("Large buttons"));

    m_cmbLayout = new QComboBox;
    m_cmbLayout->setSizeAdjustPolicy(QComboBox::AdjustToContents);
    m_cmbLayout->setMinimumWidth(160);
    m_cmbLayout->addItem(tr("Rectangle (grid)"));
    m_cmbLayout->addItem(tr("Horizontal (one row)"));
    m_cmbLayout->addItem(tr("Vertical (one column)"));
    m_cmbLayout->addItem(tr("Vertical (two columns)"));
    m_lblBtnLayout = new QLabel(tr("Button layout:"));

    ctrlForm->addRow(m_chkShowLabels);
    ctrlForm->addRow(m_chkLargeButtons);
    ctrlForm->addRow(m_lblBtnLayout, m_cmbLayout);
    winCol->addWidget(m_grpButtonControls);

    // ── Section: Feedback ─────────────────────────────────────
    m_grpFeedback = new QGroupBox(tr("Feedback"));
    auto* fbForm = new QFormLayout(m_grpFeedback);
    fbForm->setSpacing(6);

    m_chkAudio          = new QCheckBox(tr("Audio feedback on click"));
    m_chkClickIndicator = new QCheckBox(tr("Show click indicator ring (Windows)"));
    fbForm->addRow(m_chkAudio);
    fbForm->addRow(m_chkClickIndicator);
    winCol->addWidget(m_grpFeedback);

    // On-screen keyboard launcher — at the bottom of the tab.
    m_btnOnScreenKbd = new QPushButton(tr("Open On-Screen Keyboard"));
    m_btnOnScreenKbd->setFlat(true);
    winCol->addWidget(m_btnOnScreenKbd);
    winCol->addStretch(1);
    connect(m_btnOnScreenKbd, &QPushButton::clicked, this, [this]() {
        // `this` is used only by the Linux branch below, which calls the member
        // promptInstallOnScreenKeyboard(). Keep the capture — dropping it breaks
        // the Linux build — and silence the unused-capture warning on the
        // Windows/macOS branches, whose bodies are entirely static calls.
        (void)this;
#if defined(Q_OS_WIN)
        // Build full path from %SystemRoot% so PATH resolution isn't needed.
        const QString sysRoot = QString::fromLocal8Bit(qgetenv("SystemRoot"));
        const QString osk = (sysRoot.isEmpty() ? QString("C:\\Windows") : sysRoot)
                            + "\\System32\\osk.exe";
        QProcess::startDetached(osk, {});
#elif defined(Q_OS_MAC)
        // The macOS Accessibility Keyboard is a system service, not a standalone app.
        // Navigate to Accessibility > Keyboard in System Settings so the user can
        // enable it — once enabled it appears as a persistent floating keyboard.
        const int macMajor = QSysInfo::productVersion().split('.').value(0).toInt();
        if (macMajor >= 13) {
            // macOS 13 Ventura+ uses the new System Settings URL scheme
            QDesktopServices::openUrl(QUrl(
                "x-apple.systempreferences:"
                "com.apple.Accessibility-Settings.extension?Keyboard"));
        } else {
            QDesktopServices::openUrl(QUrl(
                "x-apple.systempreferences:"
                "com.apple.preference.universalaccess?Keyboard"));
        }
#else
        // Candidate list (Wayland-aware ordering) comes from
        // onscreenkeyboard.{h,cpp}, shared with the toolbar's Keyboard button.
        // Launch detached here — unlike the toolbar, this button has no second
        // click to close what it opened, so no process handle is kept.
        for (const QString& kb : OnScreenKeyboard::candidates()) {
            if (QProcess::startDetached(kb, {}))
                return;
        }
        promptInstallOnScreenKeyboard();
#endif
    });

    m_tabs->addTab(pageWin, tr("Window"));

    // ── Audio Click ───────────────────────────────────────────
    auto* pageAudio = new QWidget;
    auto* aufl      = new QVBoxLayout(pageAudio);
    aufl->setSpacing(8);

    m_chkAudioClick = new QCheckBox(tr("Trigger the selected action with a loud sound"));
    // Cyan "on" toggle so the feature's main switch matches its slider/meter.
    // Fully specifies the indicator so the sizing survives the widget stylesheet;
    // the off state keeps the grey toggle.
    m_chkAudioClick->setStyleSheet(
        "QCheckBox::indicator { width:25px; height:11px; border:none;"
        " background:transparent; image:url(:/icons/toggle_off.svg); }"
        "QCheckBox::indicator:checked { image:url(:/icons/toggle_on_cyan.svg); }");
    aufl->addWidget(m_chkAudioClick);

    m_lblAudioClickInfo = new QLabel;
    m_lblAudioClickInfo->setWordWrap(true);
    m_lblAudioClickInfo->setStyleSheet("color:#E6E6E6;");
    m_lblAudioClickInfo->setText(audioClickInfoText());
    aufl->addWidget(m_lblAudioClickInfo);

    // Device picker, threshold slider and live input meter share one grid so the
    // controls line up in a column (the slider handle sits directly above the
    // meter bar — both run on the same 0–100 scale — letting the user set the
    // threshold just below where their noise peaks).
    auto* calGrid = new QGridLayout;
    calGrid->setHorizontalSpacing(8);

    m_lblAudioDevice = new QLabel(tr("Input device:"));
    m_cmbAudioDevice = new QComboBox;
    // Fill the grid column rather than growing the dialog to the widest device
    // name (Linux device descriptions can be very long).
    m_cmbAudioDevice->setMinimumWidth(180);
    m_cmbAudioDevice->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    m_cmbAudioDevice->addItem(tr("System default"), QString());   // empty id
#ifdef HAVE_MULTIMEDIA
    for (const AudioInputInfo& d : AudioClickListener::availableInputs())
        m_cmbAudioDevice->addItem(d.name, d.id);
#endif
    calGrid->addWidget(m_lblAudioDevice, 0, 0);
    calGrid->addWidget(m_cmbAudioDevice, 0, 1, 1, 2);

    m_lblAudioThreshold = new QLabel(tr("Loudness threshold:"));
    m_audioThreshSlider = new QSlider(Qt::Horizontal);
    m_audioThreshSlider->setRange(1, 100);
    // Cyan handle + fill so the threshold slider matches the audio meter and
    // toggle (the feature's colour); the base track stays grey.
    m_audioThreshSlider->setStyleSheet(
        "QSlider::handle:horizontal { background:#00EBFF; }"
        "QSlider::sub-page:horizontal { background:#00EBFF; }");
    m_audioThreshValue  = new QLabel("50%");
    m_audioThreshValue->setFixedWidth(36);
    calGrid->addWidget(m_lblAudioThreshold, 1, 0);
    calGrid->addWidget(m_audioThreshSlider, 1, 1);
    calGrid->addWidget(m_audioThreshValue,  1, 2);

    m_lblAudioMeter = new QLabel(tr("Input level:"));
    m_audioMeter    = new QProgressBar;
    m_audioMeter->setRange(0, 100);
    m_audioMeter->setValue(0);
    m_audioMeter->setTextVisible(false);
    m_audioMeter->setFixedHeight(10);
    // Cyan level fill — matches the main-window audio meter so users correlate
    // the audio-click feature across both screens (dwell stays orange).
    m_audioMeter->setStyleSheet(
        "QProgressBar{background:#1A1A1A;border:1px solid #555;border-radius:3px;}"
        "QProgressBar::chunk{background:#00EBFF;border-radius:2px;}");
    calGrid->addWidget(m_lblAudioMeter, 2, 0);
    calGrid->addWidget(m_audioMeter,    2, 1);
    calGrid->setColumnStretch(1, 1);
    aufl->addLayout(calGrid);
    aufl->addStretch(1);

    connect(m_audioThreshSlider, &QSlider::valueChanged, this, [this](int v){
        m_audioThreshValue->setText(QString::number(v) + "%");
    });
    // Switching the input device while the meter is live restarts capture on the
    // newly-chosen microphone so calibration reflects it immediately.
    connect(m_cmbAudioDevice, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, [this](int){
#ifdef HAVE_MULTIMEDIA
        if (m_meterListener && m_meterListener->isRunning()) {
            stopAudioMeter();
            startAudioMeter();
        }
#endif
    });
    // The threshold only matters when audio click is enabled.
    auto updateAudioEnabled = [this](bool on){
        m_lblAudioThreshold->setEnabled(on);
        m_audioThreshSlider->setEnabled(on);
        m_audioThreshValue->setEnabled(on);
    };
    connect(m_chkAudioClick, &QCheckBox::toggled, this, updateAudioEnabled);

#ifndef HAVE_MULTIMEDIA
    // No audio support compiled in — show the option but make clear it is inert,
    // and hide the live meter (there is nothing to display).
    m_chkAudioClick->setEnabled(false);
    m_audioThreshSlider->setEnabled(false);
    m_cmbAudioDevice->setEnabled(false);
    m_lblAudioMeter->hide();
    m_audioMeter->hide();
#endif

    m_tabs->addTab(pageAudio, tr("Audio Click"));

    // ── Diagnostics ───────────────────────────────────────────
    buildDiagnosticsTab();

    // ── Buttons ───────────────────────────────────────────────
    m_buttons   = new QDialogButtonBox();
    m_okBtn     = m_buttons->addButton(tr("OK"),     QDialogButtonBox::AcceptRole);
    m_cancelBtn = m_buttons->addButton(tr("Cancel"), QDialogButtonBox::RejectRole);
    m_resetBtn  = m_buttons->addButton(tr("Reset to Defaults"), QDialogButtonBox::ResetRole);
    root->addWidget(m_buttons);

    syncAccessibleNames();
}

void SettingsDialog::syncAccessibleNames()
{
    // Label/field pairs.  a11y::bindLabel() sets the buddy relation and copies the
    // label's text onto the field as its accessible name, so these cost no new
    // translatable strings — the labels are already translated.
    const struct { QLabel* label; QWidget* field; } pairs[] = {
        { m_lblDwellTime,      m_dwellMs },
        { m_lblSensitivity,    m_sensitivPx },
        { m_lblHoverSelect,    m_hoverSelectPct },
        { m_lblScrollRepeat,   m_scrollRepeat },
        // These two checkboxes carry no text of their own — without the label
        // they are announced as an unnamed check box.
        { m_lblRepeatMode,     m_chkRepeatMode },
        { m_lblReturnToLeft,   m_chkReturnToLeft },
        { m_lblEdgeLock,       m_cmbEdgeLock },
        { m_lblOpacity,        m_opacitySlider },
        { m_lblMinimalWidthPx, m_spinMinimalWidthPx },
        { m_lblBtnLayout,      m_cmbLayout },
        { m_lblLanguage,       m_cmbLanguage },
        { m_lblProfile,        m_cmbProfiles },
        { m_lblAudioDevice,    m_cmbAudioDevice },
        { m_lblAudioThreshold, m_audioThreshSlider },
        { m_lblAudioMeter,     m_audioMeter },
#ifdef Q_OS_MAC
        { m_lblPermissions,    m_btnAccessibility },
#endif
    };
    for (const auto& p : pairs)
        a11y::bindLabel(p.label, p.field);

    // The reorder list's heading is a section header carrying instructions, not a
    // field label, so it is neither a buddy candidate nor short enough to announce
    // on every focus change — split it into a name and a description.
    a11y::setName(m_btnOrderList, tr("Visible buttons"),
                  a11y::labelToName(m_lblVisibleButtons->text()));

    // Zoom controls: the glyphs are "−" and "+", which a screen reader reads as
    // punctuation, and the one "Zoom:" label cannot name both buttons.
    a11y::setName(m_btnZoomOut, tr("Decrease text size"));
    a11y::setName(m_btnZoomIn,  tr("Increase text size"));
    a11y::setName(m_lblZoomValue, tr("Text size"));

    // The log path read-out is a bare value with its heading two widgets away, so
    // nothing names it; the buttons and checkbox next to it carry their own text.
    a11y::setName(m_lblLogStatus, tr("Log file location"));

    // Each hotkey row is one label against two fields, so the buddy relation
    // cannot disambiguate them.
    for (int i = 0; i < 3; ++i) {
        a11y::setName(m_edtHotkeyLabel[i], tr("Hotkey %1 label").arg(i + 1),
                      tr("Button label shown on the toolbar. Defaults to the key name if left blank."));
        a11y::setName(m_kseHotkey[i], tr("Hotkey %1 shortcut").arg(i + 1),
                      tr("Click here and press the desired key combination (e.g. F12, Ctrl+A, Alt+Z)."));
    }
}

// ── Diagnostics tab ──────────────────────────────────────────────────────────
namespace {

// One row of the environment read-out.
// status: -1 problem (red), 0 neutral, 1 good (green), 2 audio feature (cyan).
struct DiagRow { QString key; QString value; int status; };

// How much of the log "Copy diagnostics" carries.  Enough to cover a launch and
// the problem that followed it, short enough to paste into an issue.
constexpr int k_diagLogLines = 120;

QString injectionBackend()
{
#if defined(Q_OS_WIN)
    return QStringLiteral("SendInput (Win32)");
#elif defined(Q_OS_MAC)
    return QStringLiteral("CGEvent (Quartz)");
#elif defined(Q_OS_LINUX)
    return QStringLiteral("XTest (X11 / XWayland)");
#else
    return QStringLiteral("unsupported platform");
#endif
}

QVector<DiagRow> collectDiagRows(bool audioClickEnabled)
{
    QVector<DiagRow> rows;

    rows.push_back({ SettingsDialog::tr("TrackClick version"), displayVersion(), 0 });
    rows.push_back({ SettingsDialog::tr("Operating system"), QSysInfo::prettyProductName(), 0 });
    rows.push_back({ SettingsDialog::tr("Windowing system"), QGuiApplication::platformName(), 0 });
    rows.push_back({ SettingsDialog::tr("Click backend"),    injectionBackend(),            0 });

    const bool access = ClickInjector::hasInputDeviceAccess();
#if defined(Q_OS_MAC)
    rows.push_back({ SettingsDialog::tr("Accessibility permission"),
                     access ? SettingsDialog::tr("Granted")
                            : SettingsDialog::tr("NOT granted — clicks are blocked"),
                     access ? 1 : -1 });
#elif defined(Q_OS_LINUX)
    rows.push_back({ SettingsDialog::tr("Pointer tracking (evdev)"),
                     access ? SettingsDialog::tr("Available")
                            : SettingsDialog::tr("Unavailable — needed for dwell tracking on Wayland"),
                     access ? 1 : -1 });
#else
    rows.push_back({ SettingsDialog::tr("Input injection"),
                     access ? SettingsDialog::tr("Available") : SettingsDialog::tr("Unavailable"),
                     access ? 1 : -1 });
#endif

    // Which trigger fires clicks: audio click replaces the dwell timer when on,
    // otherwise the dwell timer is active.
    rows.push_back({ SettingsDialog::tr("Click trigger"),
                     audioClickEnabled ? SettingsDialog::tr("Audio click")
                                       : SettingsDialog::tr("Dwell click"),
                     audioClickEnabled ? 2 : 0 });   // 2 → cyan when audio click is on
    return rows;
}

} // namespace

void SettingsDialog::buildDiagnosticsTab()
{
    auto* page = new QWidget;
    auto* v    = new QVBoxLayout(page);
    v->setSpacing(8);

    m_lblDiagIntro = new QLabel(
        tr("If clicking isn't working, this information helps pin down why."));
    m_lblDiagIntro->setWordWrap(true);
    v->addWidget(m_lblDiagIntro);

    // Environment read-out (rich text; colours flag problem rows).
    m_lblDiagInfo = new QLabel;
    m_lblDiagInfo->setTextInteractionFlags(Qt::TextSelectableByMouse);
    m_lblDiagInfo->setStyleSheet(
        "background:#1E1E1E; border:1px solid #444; border-radius:4px; padding:6px;");
    v->addWidget(m_lblDiagInfo);

    m_btnCopyDiag = new QPushButton(tr("Copy diagnostics"));
    m_btnCopyDiag->setProperty("flat", true);
    connect(m_btnCopyDiag, &QPushButton::clicked, this, [this]() {
        QApplication::clipboard()->setText(diagnosticsPlainText());
        m_btnCopyDiag->setText(tr("Copied!"));
        QTimer::singleShot(1500, m_btnCopyDiag, [this]() {
            if (m_btnCopyDiag) m_btnCopyDiag->setText(tr("Copy diagnostics"));
        });
    });
    v->addWidget(m_btnCopyDiag, 0, Qt::AlignLeft);

    auto* sep = new QFrame;
    sep->setFrameShape(QFrame::HLine);
    sep->setStyleSheet("QFrame { color:#555; }");
    v->addWidget(sep);

    m_lblSelfTestHelp = new QLabel(
        tr("Click self-test: TrackClick moves the pointer to the target below and "
           "injects a real click. If the target lights up green, click injection "
           "is working end-to-end."));
    m_lblSelfTestHelp->setWordWrap(true);
    v->addWidget(m_lblSelfTestHelp);

    auto* testRow = new QHBoxLayout;
    m_btnSelfTest = new QPushButton(tr("Run click self-test"));
    connect(m_btnSelfTest, &QPushButton::clicked, this, &SettingsDialog::runClickSelfTest);
    testRow->addWidget(m_btnSelfTest);

    // The synthetic click is aimed here; its clicked() proves the event landed.
    m_diagTarget = new QPushButton(tr("Target"));
    m_diagTarget->setFixedSize(90, 40);
    m_diagTarget->setFocusPolicy(Qt::NoFocus);
    const QString targetIdle =
        "QPushButton { background:#3A3A3A; color:#DDD; border:2px solid #666; border-radius:5px; }";
    const QString targetHit =
        "QPushButton { background:#204A26; color:#FFF; border:2px solid #3FB950; border-radius:5px; }";
    m_diagTarget->setStyleSheet(targetIdle);
    connect(m_diagTarget, &QPushButton::clicked, this, [this, targetIdle, targetHit]() {
        m_selfTestHit = true;
        m_diagTarget->setStyleSheet(targetHit);
        QTimer::singleShot(600, m_diagTarget, [this, targetIdle]() {
            if (m_diagTarget) m_diagTarget->setStyleSheet(targetIdle);
        });
    });
    testRow->addWidget(m_diagTarget);
    testRow->addStretch(1);
    v->addLayout(testRow);

    m_lblSelfTestResult = new QLabel;
    m_lblSelfTestResult->setWordWrap(true);
    v->addWidget(m_lblSelfTestResult);

    buildLogSection(v);

    buildProfilesSection(v);

    // ── Privacy / usage reporting opt-out ────────────────────────────────────
    auto* sepUsage = new QFrame;
    sepUsage->setFrameShape(QFrame::HLine);
    sepUsage->setStyleSheet("QFrame { color:#555; }");
    v->addWidget(sepUsage);

    m_chkUsageReporting = new QCheckBox(tr("Send anonymous usage statistics"));
    v->addWidget(m_chkUsageReporting);

    m_lblUsageReporting = new QLabel(usageReportingInfoText());
    m_lblUsageReporting->setWordWrap(true);
    m_lblUsageReporting->setStyleSheet("color:#AAA;");
    // A word-wrapped QLabel still reports a one-line sizeHint width, so a
    // paragraph this long would widen the whole dialog (badly at 200% font
    // scale).  Ignored horizontally means it wraps into whatever width the tab
    // already has instead of dictating it.
    m_lblUsageReporting->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum);
    v->addWidget(m_lblUsageReporting);

    v->addStretch(1);

    // Keep the "Click trigger" row live: toggling Audio Click (here or via the
    // Audio Click tab) updates the read-out immediately.  This connect is made
    // before loadFrom() runs, so the initial value syncs too.
    if (m_chkAudioClick)
        connect(m_chkAudioClick, &QCheckBox::toggled,
                this, &SettingsDialog::refreshDiagnostics);

    refreshDiagnostics();
    // This tab carries the most content of any (environment read-out, self-test,
    // profiles, privacy) and it is the one that sets the dialog's minimum
    // height.  At a 200% settings font scale that overflowed a 1080p screen,
    // which for a user who cannot easily drag a window means controls they
    // simply cannot reach.  Scrolling the page keeps the dialog a sane size at
    // every font scale, and leaves room for future additions here.
    m_diagScroll = new QScrollArea;
    m_diagScroll->setWidget(page);
    m_diagScroll->setWidgetResizable(true);
    m_diagScroll->setFrameShape(QFrame::NoFrame);
    m_diagScroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    m_tabs->addTab(m_diagScroll, tr("Diagnostics"));
}

// ── Log file section ─────────────────────────────────────────────────────────
// Sits directly under the self-test, because the two answer the same question in
// escalating order: the self-test says whether clicking works *now*, and the log
// says what happened on the way there — above all which pointer-tracking backend
// was selected at start-up, which is the usual root cause when dwell-clicking
// works over the toolbar and nowhere else (INTERNAL §2).
void SettingsDialog::buildLogSection(QVBoxLayout* v)
{
    auto* sep = new QFrame;
    sep->setFrameShape(QFrame::HLine);
    sep->setStyleSheet("QFrame { color:#555; }");
    v->addWidget(sep);

    m_lblLogHeading = new QLabel(tr("Log file"));
    // Matches the "Profiles and backup" heading below: bold only, taking its
    // colour from the dialog stylesheet's QLabel rule.
    m_lblLogHeading->setStyleSheet("font-weight:bold;");
    v->addWidget(m_lblLogHeading);

    m_lblLogHelp = new QLabel(logHelpText());
    m_lblLogHelp->setWordWrap(true);
    m_lblLogHelp->setStyleSheet("color:#AAA;");
    // Same reason as the usage-reporting paragraph below: a wrapped label still
    // reports a single-line width hint and would widen the whole dialog.
    m_lblLogHelp->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum);
    v->addWidget(m_lblLogHelp);

    m_chkLogging = new QCheckBox(tr("Write a log file"));
    m_chkLogging->setChecked(logging::isEnabled());
    // Applies immediately, not on OK: the point of the switch is to stop or start
    // writing right now, and the surrounding controls (Clear, the size read-out)
    // would otherwise describe a state that has not taken effect yet.
    connect(m_chkLogging, &QCheckBox::toggled, this, [this](bool on) {
        logging::setEnabled(on);
        refreshLogStatus();
    });
    v->addWidget(m_chkLogging);

    m_lblLogStatus = new QLabel;
    m_lblLogStatus->setWordWrap(true);
    m_lblLogStatus->setTextInteractionFlags(Qt::TextSelectableByMouse);
    m_lblLogStatus->setStyleSheet("color:#9AA0A6;");
    m_lblLogStatus->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum);
    v->addWidget(m_lblLogStatus);

    auto* logRow = new QHBoxLayout;
    m_btnOpenLogFolder = new QPushButton(tr("Open log folder"));
    m_btnOpenLogFolder->setProperty("flat", true);
    connect(m_btnOpenLogFolder, &QPushButton::clicked, this, []() {
        const QString dir = logging::dirPath();
        // The directory is created lazily on the first write, so it may not exist
        // yet on a fresh install with logging switched off.  Create it rather than
        // opening nothing and looking broken.
        QDir().mkpath(dir);
        QDesktopServices::openUrl(QUrl::fromLocalFile(dir));
    });
    logRow->addWidget(m_btnOpenLogFolder);

    m_btnClearLog = new QPushButton(tr("Clear log"));
    m_btnClearLog->setProperty("flat", true);
    connect(m_btnClearLog, &QPushButton::clicked, this, [this]() {
        logging::clear();
        refreshLogStatus();
    });
    logRow->addWidget(m_btnClearLog);
    logRow->addStretch(1);
    v->addLayout(logRow);

    refreshLogStatus();
}

void SettingsDialog::refreshLogStatus()
{
    if (!m_lblLogStatus)
        return;

    const qint64 bytes = logging::sizeBytes();
    QString text = logging::filePath();
    if (bytes > 0) {
        text += QStringLiteral("  (%1)")
                    .arg(QLocale().formattedDataSize(bytes, 1, QLocale::DataSizeTraditionalFormat));
    } else {
        text += QStringLiteral("  (%1)").arg(tr("empty"));
    }
    m_lblLogStatus->setText(text);

    // Nothing to clear when the file is absent, and the button saying otherwise
    // invites a click that appears to do nothing.
    if (m_btnClearLog)
        m_btnClearLog->setEnabled(bytes > 0);
}

void SettingsDialog::refreshDiagnostics()
{
    if (!m_lblDiagInfo)
        return;
    QString html = QStringLiteral("<table cellspacing='0' cellpadding='3'>");
    for (const DiagRow& r : collectDiagRows(m_chkAudioClick && m_chkAudioClick->isChecked())) {
        const QString colour = r.status < 0  ? QStringLiteral("#E5534B")
                             : r.status == 2 ? QStringLiteral("#00EBFF")
                             : r.status > 0  ? QStringLiteral("#3FB950")
                                             : QStringLiteral("#E6E6E6");
        html += QStringLiteral("<tr><td style='color:#9AA0A6;'>%1&nbsp;&nbsp;</td>"
                               "<td style='color:%2;'><b>%3</b></td></tr>")
                    .arg(r.key.toHtmlEscaped(), colour, r.value.toHtmlEscaped());
    }
    html += QStringLiteral("</table>");
    m_lblDiagInfo->setText(html);
}

QString SettingsDialog::diagnosticsPlainText() const
{
    QString out = QStringLiteral("TrackClick diagnostics\n----------------------\n");
    for (const DiagRow& r : collectDiagRows(m_chkAudioClick && m_chkAudioClick->isChecked()))
        out += r.key + QStringLiteral(": ") + r.value + QChar('\n');

    // Append the recent log so one paste carries both the environment and what
    // actually happened in it — the whole point of keeping the file.  Capped
    // well below the file's own limit: a bug report pasted into an issue or a
    // chat window has to stay readable, and the lines that explain a start-up
    // problem are at the end anyway.
    out += QStringLiteral("\nLog file: ") + logging::filePath() + QChar('\n');
    if (!logging::isEnabled()) {
        out += QStringLiteral("(logging is switched off)\n");
    } else {
        const QString recent = logging::tail(k_diagLogLines);
        if (recent.isEmpty()) {
            out += QStringLiteral("(log is empty)\n");
        } else {
            out += QStringLiteral("--- last %1 lines ---\n").arg(k_diagLogLines);
            out += recent;
            out += QChar('\n');
        }
    }
    return out;
}

void SettingsDialog::runClickSelfTest()
{
    if (!m_diagTarget || !m_btnSelfTest || !m_lblSelfTestResult)
        return;

    m_selfTestHit = false;
    m_btnSelfTest->setEnabled(false);
    m_lblSelfTestResult->setStyleSheet("color:#E6A100; background:transparent;");
    m_lblSelfTestResult->setText(tr("Testing… please don't move the mouse."));

    // The page scrolls, so the target may be parked outside the viewport.  Its
    // global position would still map fine, but the click would land on whatever
    // is actually drawn there and the test would report a false failure.  Bring
    // it into view and let the layout settle before reading the position.
    if (m_diagScroll) {
        m_diagScroll->ensureWidgetVisible(m_diagTarget);
        QCoreApplication::processEvents();
    }

    // Aim at the target's centre and remember the pointer's spot so it can be
    // restored — the test drives the real system cursor to deliver a real click.
    const QPoint target = m_diagTarget->mapToGlobal(m_diagTarget->rect().center());
    const QPoint saved  = ClickInjector::cursorPos();

    ClickInjector::moveCursor(target);

    // Let the move settle, inject the click, then evaluate after it round-trips
    // through the OS back to the target widget.
    QTimer::singleShot(120, this, [this, target, saved]() {
        ClickInjector::performClick(ClickType::LeftClick, target);
        QTimer::singleShot(350, this, [this, saved]() {
            ClickInjector::moveCursor(saved);          // put the pointer back
            if (m_btnSelfTest) m_btnSelfTest->setEnabled(true);
            if (!m_lblSelfTestResult) return;
            if (m_selfTestHit) {
                m_lblSelfTestResult->setStyleSheet("color:#3FB950; background:transparent;");
                m_lblSelfTestResult->setText(
                    tr("PASS — the injected click was delivered. Click injection works."));
            } else {
                m_lblSelfTestResult->setStyleSheet("color:#E5534B; background:transparent;");
                m_lblSelfTestResult->setText(
                    tr("FAIL — the click was injected but never arrived. This usually "
                       "means TrackClick lacks permission to control the mouse."));
            }
        });
    });
}

#ifdef Q_OS_LINUX
void SettingsDialog::promptInstallOnScreenKeyboard()
{
    // Build the install command for "onboard" (the keyboard the launcher tries
    // first, packaged on every major distro) using whichever package manager is
    // present.  Elevation is done with pkexec so the user gets a graphical
    // password prompt rather than needing a terminal.
    const QString pkexec = QStandardPaths::findExecutable("pkexec");
    QStringList   installArgs;
    if (!QStandardPaths::findExecutable("apt-get").isEmpty())
        installArgs = {"env", "DEBIAN_FRONTEND=noninteractive",
                       "apt-get", "install", "-y", "onboard"};
    else if (!QStandardPaths::findExecutable("dnf").isEmpty())
        installArgs = {"dnf", "install", "-y", "onboard"};
    else if (!QStandardPaths::findExecutable("zypper").isEmpty())
        installArgs = {"zypper", "--non-interactive", "install", "onboard"};
    else if (!QStandardPaths::findExecutable("pacman").isEmpty())
        installArgs = {"pacman", "-S", "--noconfirm", "onboard"};

    // Without pkexec or a recognised package manager, fall back to advising.
    if (pkexec.isEmpty() || installArgs.isEmpty()) {
        QMessageBox::information(this, tr("On-Screen Keyboard"),
            tr("No on-screen keyboard was found.\n"
               "Please install 'onboard' or 'florence'."));
        return;
    }

    if (QMessageBox::question(this, tr("On-Screen Keyboard"),
            tr("No on-screen keyboard is installed. Install 'onboard' now?\n"
               "You'll be asked for your password."),
            QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) != QMessageBox::Yes)
        return;

    // Run the install asynchronously behind a busy dialog so the settings
    // window stays responsive during the download.
    auto* proc     = new QProcess(this);
    auto* progress = new QProgressDialog(tr("Installing on-screen keyboard…"),
                                         QString(), 0, 0, this);
    progress->setWindowTitle(tr("On-Screen Keyboard"));
    progress->setWindowModality(Qt::WindowModal);
    progress->setMinimumDuration(0);
    progress->setCancelButton(nullptr);   // apt cannot be safely interrupted mid-run
    progress->show();

    connect(proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
            this, [this, proc, progress](int code, QProcess::ExitStatus status) {
        progress->close();
        progress->deleteLater();
        proc->deleteLater();
        if (status == QProcess::NormalExit && code == 0) {
            if (!QProcess::startDetached("onboard", {}))
                QMessageBox::information(this, tr("On-Screen Keyboard"),
                    tr("'onboard' was installed. Click the button again to open it."));
        } else {
            QMessageBox::warning(this, tr("On-Screen Keyboard"),
                tr("The on-screen keyboard could not be installed automatically.\n"
                   "You can install it from a terminal with:  sudo apt install onboard"));
        }
    });
    connect(proc, &QProcess::errorOccurred, this,
            [this, proc, progress](QProcess::ProcessError e) {
        if (e != QProcess::FailedToStart)
            return;   // other errors are followed by finished(), handled above
        progress->close();
        progress->deleteLater();
        proc->deleteLater();
        QMessageBox::warning(this, tr("On-Screen Keyboard"),
            tr("Could not launch the installer (pkexec).\n"
               "You can install it from a terminal with:  sudo apt install onboard"));
    });

    proc->start(pkexec, installArgs);
}
#endif

void SettingsDialog::applyFontScale()
{
    m_fontScale = qBound(kZoomMinPct, m_fontScale, kZoomMaxPct);
    setStyleSheet(buildStyle(qRound(kBaseFontPx * m_fontScale / 100.0)));
    if (m_lblZoomValue)
        m_lblZoomValue->setText(QString::number(m_fontScale) + "%");
    // Grey out a button once its limit is reached.
    if (m_btnZoomOut) m_btnZoomOut->setEnabled(m_fontScale > kZoomMinPct);
    if (m_btnZoomIn)  m_btnZoomIn->setEnabled(m_fontScale < kZoomMaxPct);
}

// Display label for a click-button id.  These strings intentionally match the
// former checkbox labels so existing translations keep working.
QString SettingsDialog::clickButtonLabel(const QString& id) const
{
    if (id == QLatin1String("no_click"))      return tr("No Click");
    if (id == QLatin1String("left_click"))    return tr("Left Click");
    if (id == QLatin1String("left_double"))   return tr("Left Double");
    if (id == QLatin1String("left_drag"))     return tr("Left Drag");
    if (id == QLatin1String("right_click"))   return tr("Right Click");
    if (id == QLatin1String("right_double"))  return tr("Right Double");
    if (id == QLatin1String("right_drag"))    return tr("Right Drag");
    if (id == QLatin1String("middle_click"))  return tr("Middle Click");
    if (id == QLatin1String("middle_double")) return tr("Middle Double");
    if (id == QLatin1String("scroll_up"))     return tr("Scroll Up");
    if (id == QLatin1String("scroll_down"))   return tr("Scroll Down");
    if (id == QLatin1String("scroll_horiz"))  return tr("Scroll Left/Right");
    if (id == QLatin1String("ctrl"))          return tr("Ctrl Modifier");
    if (id == QLatin1String("alt"))           return tr("Alt Modifier");
    if (id == QLatin1String("shift"))         return tr("Shift Modifier");
    if (id == QLatin1String("dwell_active"))  return tr("Dwell Active Button");
    if (id == QLatin1String("quit"))          return tr("Quit Button");
    if (id == QLatin1String("keyboard"))      return tr("Keyboard Button");
    const int hk = hotkeyIndexForId(id);
    if (hk >= 0)                              return tr("Hotkey %1").arg(hk + 1);
    return id;
}

void SettingsDialog::moveSelectedButton(int delta)
{
    const int r = m_btnOrderList->currentRow();
    if (r < 0) return;
    const int nr = r + delta;
    if (nr < 0 || nr >= m_btnOrderList->count()) return;
    // takeItem/insertItem preserves the item's check state and stored id.
    QListWidgetItem* item = m_btnOrderList->takeItem(r);
    m_btnOrderList->insertItem(nr, item);
    m_btnOrderList->setCurrentRow(nr);   // keep the moved row selected
    updateMoveButtons();
}

void SettingsDialog::updateMoveButtons()
{
    const int r = m_btnOrderList->currentRow();
    const int n = m_btnOrderList->count();
    if (m_btnMoveUp)   m_btnMoveUp->setEnabled(r > 0);
    if (m_btnMoveDown) m_btnMoveDown->setEnabled(r >= 0 && r < n - 1);
}

void SettingsDialog::loadFrom(const AppSettings& s)
{
    m_dwellMs->setValue(s.dwellMs);
    m_sensitivPx->setValue(s.sensitivityPx);
    m_hoverSelectPct->setValue(s.hoverSelectPercent);
    m_scrollRepeat->setValue(s.scrollRepeat);
    m_chkRepeatMode->setChecked(s.repeatOnDwell);
    m_chkReturnToLeft->setChecked(s.returnToLeftAfterClick);

    // Populate the reorder list in the saved order, with saved visibility as the
    // check state.  Right Double / Right Drag stay read-only and off, so they're
    // not listed here.
    m_btnOrderList->clear();
    for (const QString& id : orderedClickButtonIds(s)) {
        if (id == QLatin1String("right_double") || id == QLatin1String("right_drag"))
            continue;
        auto* item = new QListWidgetItem(clickButtonLabel(id), m_btnOrderList);
        item->setData(Qt::UserRole, id);
        item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
        item->setCheckState(buttonEnabled(s, id) ? Qt::Checked : Qt::Unchecked);
    }
    if (m_btnOrderList->count() > 0)
        m_btnOrderList->setCurrentRow(0);
    updateMoveButtons();

    m_cmbEdgeLock->setCurrentIndex(static_cast<int>(s.edgeLock));
    m_chkEdgeHide->setChecked(s.edgeHide);
    m_chkEdgeHide->setEnabled(s.edgeLock != EdgeLock::None);

    m_opacitySlider->setValue(static_cast<int>(s.windowOpacity * 100));
    m_chkAlwaysOnTop->setChecked(s.alwaysOnTop);
    m_chkStartMinimized->setChecked(s.startMinimized);
    // Top X minimizes app is intentionally left read-only and unchecked (see
    // buildUi); don't drive it from settings. Restore this line to re-enable.
    m_chkLaunchOnStartup->setChecked(s.launchOnStartup);
    m_chkMinimalWidth->setChecked(s.minimalWidth);
    m_spinMinimalWidthPx->setValue(s.minimalWidthPx);
    m_lblMinimalWidthPx->setEnabled(s.minimalWidth);
    m_spinMinimalWidthPx->setEnabled(s.minimalWidth);
    m_chkAudio->setChecked(s.audioFeedback);
    m_chkClickIndicator->setChecked(s.showClickIndicator);
    m_chkUsageReporting->setChecked(s.usageReporting);
    m_chkShowLabels->setChecked(!s.iconsOnly);   // checked = labels shown
    m_chkLargeButtons->setChecked(s.largeButtons);
    m_cmbLayout->setCurrentIndex(static_cast<int>(s.buttonLayout));
    for (int i = 0; i < m_cmbLanguage->count(); ++i) {
        if (m_cmbLanguage->itemData(i).toString() == s.language) {
            m_cmbLanguage->setCurrentIndex(i);
            break;
        }
    }

    m_fontScale = s.settingsFontScale;
    applyFontScale();

    m_chkAudioClick->setChecked(s.audioClickEnabled);
    m_audioThreshSlider->setValue(s.audioClickThreshold);
    m_audioThreshValue->setText(QString::number(s.audioClickThreshold) + "%");
    m_lblAudioThreshold->setEnabled(s.audioClickEnabled);
    m_audioThreshSlider->setEnabled(s.audioClickEnabled);
    m_audioThreshValue->setEnabled(s.audioClickEnabled);

    // Select the saved input device (index 0 / "System default" if not found,
    // e.g. the device was unplugged or the id came from another machine).
    int devIdx = m_cmbAudioDevice->findData(s.audioInputDevice);
    m_cmbAudioDevice->setCurrentIndex(devIdx >= 0 ? devIdx : 0);

    // Hotkey on/off is edited in the reorder list; the label + key fields stay
    // editable here regardless of enabled state.
    for (int i = 0; i < 3; ++i) {
        m_edtHotkeyLabel[i]->setText(s.hotkeys[i].label);
        m_kseHotkey[i]->setKeySequence(QKeySequence(s.hotkeys[i].keySequence));
    }
}

AppSettings SettingsDialog::readUi() const
{
    AppSettings s;
    s.dwellMs       = m_dwellMs->value();
    s.sensitivityPx = m_sensitivPx->value();
    s.hoverSelectPercent = m_hoverSelectPct->value();
    s.scrollRepeat  = m_scrollRepeat->value();
    s.repeatOnDwell = m_chkRepeatMode->isChecked();
    s.returnToLeftAfterClick = m_chkReturnToLeft->isChecked();

    // Read click-button order and per-button visibility from the reorder list.
    // Right Double / Right Drag aren't listed, so they keep their default (off).
    s.buttonOrder.clear();
    for (int i = 0; i < m_btnOrderList->count(); ++i) {
        QListWidgetItem* item = m_btnOrderList->item(i);
        const QString id = item->data(Qt::UserRole).toString();
        s.buttonOrder << id;
        setButtonEnabled(s, id, item->checkState() == Qt::Checked);
    }

    s.edgeLock = static_cast<EdgeLock>(m_cmbEdgeLock->currentIndex());
    s.edgeHide = m_chkEdgeHide->isChecked() && (s.edgeLock != EdgeLock::None);

    s.windowOpacity   = m_opacitySlider->value() / 100.0;
    s.alwaysOnTop      = m_chkAlwaysOnTop->isChecked();
    s.startMinimized   = m_chkStartMinimized->isChecked();
    s.xMinimizesApp    = m_chkXMinimizesApp->isChecked();
    s.launchOnStartup  = m_chkLaunchOnStartup->isChecked();
    s.minimalWidth     = m_chkMinimalWidth->isChecked();
    s.minimalWidthPx   = m_spinMinimalWidthPx->value();
    s.audioFeedback       = m_chkAudio->isChecked();
    s.showClickIndicator  = m_chkClickIndicator->isChecked();
    s.usageReporting      = m_chkUsageReporting->isChecked();
    s.iconsOnly           = !m_chkShowLabels->isChecked();   // unchecked = icons only
    s.largeButtons    = m_chkLargeButtons->isChecked();
    s.buttonLayout    = static_cast<ButtonLayout>(m_cmbLayout->currentIndex());
    s.language        = m_cmbLanguage->currentData().toString();
    s.settingsFontScale = m_fontScale;

    s.audioClickEnabled   = m_chkAudioClick->isChecked();
    s.audioClickThreshold = m_audioThreshSlider->value();
    s.audioInputDevice    = m_cmbAudioDevice->currentData().toString();

    // Hotkey on/off comes from the reorder list above; here we only read the
    // editable label + key sequence for each slot.
    for (int i = 0; i < 3; ++i) {
        s.hotkeys[i].label       = m_edtHotkeyLabel[i]->text().trimmed();
        s.hotkeys[i].keySequence = m_kseHotkey[i]->keySequence()
                                       .toString(QKeySequence::PortableText);
    }
    return s;
}

#include "settingsdialog.moc"