aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/config.cpp62
-rw-r--r--src/config.h24
-rw-r--r--src/keymap.cpp12
-rw-r--r--src/mainwindow.cpp122
-rw-r--r--src/mainwindow.h17
-rw-r--r--src/messageview.cpp93
-rw-r--r--src/messageview.h24
7 files changed, 346 insertions, 8 deletions
diff --git a/src/config.cpp b/src/config.cpp
index f21bba9..e92c7f3 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -52,8 +52,40 @@ void Config::load(const QString &path)
{
QSettings settings(path, QSettings::IniFormat);
+ // Keys of [general] are read WITHOUT the "general/" prefix. QSettings'
+ // INI backend treats a section literally named [general] as its own
+ // fallback section and strips the prefix, so "general/notmuch_config"
+ // never matches anything, in any section arrangement (verified on
+ // Qt 6.11). The file still reads as [general] to the user; only the
+ // lookup differs. Same family of trap as the [account.work] dot and the
+ // childKeys() ordering already documented in CLAUDE.md.
m_notmuchConfig =
- settings.value(QStringLiteral("general/notmuch_config")).toString();
+ settings.value(QStringLiteral("notmuch_config")).toString();
+
+ // Absent is fine and silent: the default is 1.0. Present but unparseable
+ // is a problem, since the user asked for something and is not getting it.
+ // The range check lives in MessageView::clampZoom(), the one place that
+ // knows what the web view can render.
+ // Empty is treated as unset rather than as "a query named nothing".
+ const QString startup =
+ settings.value(QStringLiteral("startup_query")).toString().trimmed();
+ if (!startup.isEmpty()) {
+ m_startupQuery = startup;
+ m_startupQueryWasSet = true;
+ }
+
+ const QVariant zoom = settings.value(QStringLiteral("message_zoom"));
+ if (zoom.isValid()) {
+ bool ok = false;
+ const double value = zoom.toString().toDouble(&ok);
+ if (ok) {
+ m_messageZoom = value;
+ } else {
+ addProblem(QStringLiteral("Message zoom '%1' is not a number; "
+ "using the default.")
+ .arg(zoom.toString()));
+ }
+ }
m_syncCommand = settings.value(QStringLiteral("sync/command")).toString();
if (m_syncCommand.isEmpty()) {
@@ -125,6 +157,34 @@ void Config::load(const QString &path)
for (const QString &name : settings.childKeys())
m_savedQueries.append({ name, settings.value(name).toString() });
settings.endGroup();
+
+ // Checked here rather than where startup_query is read: [queries] is not
+ // parsed until now. Only a name the user actually wrote is worth a
+ // problem; the built-in default naming a query they never created is not
+ // something they got wrong.
+ if (m_startupQueryWasSet && !m_savedQueries.isEmpty()
+ && startupSavedQuery().name.compare(m_startupQuery,
+ Qt::CaseInsensitive) != 0) {
+ addProblem(QStringLiteral("Startup query '%1' is not a saved query; "
+ "opening '%2' instead.")
+ .arg(m_startupQuery, startupSavedQuery().name));
+ }
+}
+
+SavedQuery Config::startupSavedQuery() const
+{
+ if (m_savedQueries.isEmpty())
+ return {};
+
+ for (const SavedQuery &query : m_savedQueries) {
+ if (query.name.compare(m_startupQuery, Qt::CaseInsensitive) == 0)
+ return query;
+ }
+
+ // Named a query that does not exist. Not worth a warning: the default is
+ // a name the user never wrote, so an install with no [queries] Unread
+ // entry would warn on every launch about a key it never set.
+ return m_savedQueries.first();
}
Account Config::account(const QString &key) const
diff --git a/src/config.h b/src/config.h
index 943cbd8..3b7fc48 100644
--- a/src/config.h
+++ b/src/config.h
@@ -78,6 +78,23 @@ public:
/// Optional alternate notmuch config file. Empty means "let notmuch decide".
QString notmuchConfig() const { return m_notmuchConfig; }
+ /// The saved query to open at startup, by name. Falls back to "Unread"
+ /// when unset, and to the first saved query when no query by that name
+ /// exists: [queries] is read through childKeys(), which sorts
+ /// alphabetically, so "first" would otherwise mean whatever happens to
+ /// sort first rather than anything the user chose.
+ QString startupQuery() const { return m_startupQuery; }
+
+ /// The saved query startupQuery() names, or the first one when it names
+ /// nothing that exists. A default-constructed SavedQuery when there are
+ /// none at all.
+ SavedQuery startupSavedQuery() const;
+
+ /// Starting message-pane zoom for a profile with no saved UI state. Once
+ /// the user zooms, the state file remembers that instead, so this is only
+ /// ever the default. Clamped by MessageView::clampZoom() on use.
+ qreal messageZoom() const { return m_messageZoom; }
+
/// Every non-fatal problem, both kinds below. Shown in the status bar.
QStringList warnings() const { return m_warnings; }
@@ -101,6 +118,13 @@ private:
QList<SavedQuery> m_savedQueries;
QString m_syncCommand;
QString m_notmuchConfig;
+ qreal m_messageZoom = 1.0;
+ QString m_startupQuery = QStringLiteral("Unread");
+
+ /// Whether startup_query came from the config rather than being the
+ /// built-in default. Only a name the user wrote is worth reporting when
+ /// it matches no saved query.
+ bool m_startupQueryWasSet = false;
QStringList m_warnings;
QStringList m_problems;
};
diff --git a/src/keymap.cpp b/src/keymap.cpp
index 42ccd40..22c8da1 100644
--- a/src/keymap.cpp
+++ b/src/keymap.cpp
@@ -35,6 +35,9 @@ QStringList KeyMap::knownActions()
QStringLiteral("focus_query"),
QStringLiteral("toggle_html"),
QStringLiteral("load_remote"),
+ QStringLiteral("zoom_in"),
+ QStringLiteral("zoom_out"),
+ QStringLiteral("zoom_reset"),
QStringLiteral("undo"),
QStringLiteral("sync"),
QStringLiteral("quit"),
@@ -63,6 +66,15 @@ QList<QPair<QString, QString>> KeyMap::defaultBindings()
{ QStringLiteral("Ctrl+L"), QStringLiteral("focus_query") },
{ QStringLiteral("Ctrl+H"), QStringLiteral("toggle_html") },
{ QStringLiteral("Ctrl+M"), QStringLiteral("load_remote") },
+ // Ctrl++ is what the '+' key really delivers on a layout where '+' is
+ // unshifted, an Italian one among them, confirmed against the actual
+ // keyboard. QTest::keyClick() cannot reproduce it, so a synthetic-input
+ // probe wrongly reports this binding as dead; do not "fix" it on that
+ // evidence. A US layout, where '+' is Shift+'=', wants Ctrl+Shift+= in
+ // [keys] instead.
+ { QStringLiteral("Ctrl++"), QStringLiteral("zoom_in") },
+ { QStringLiteral("Ctrl+-"), QStringLiteral("zoom_out") },
+ { QStringLiteral("Ctrl+0"), QStringLiteral("zoom_reset") },
{ QStringLiteral("Ctrl+Z"), QStringLiteral("undo") },
{ QStringLiteral("Ctrl+G"), QStringLiteral("sync") },
{ QStringLiteral("Ctrl+Q"), QStringLiteral("quit") },
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 48b475c..2a79988 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -19,9 +19,12 @@
#include "mainwindow.h"
#include <QAction>
+#include <QCloseEvent>
#include <QComboBox>
#include <QDialog>
#include <QDialogButtonBox>
+#include <QDir>
+#include <QFileInfo>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QLabel>
@@ -33,6 +36,7 @@
#include <QPushButton>
#include <QSettings>
#include <QSplitter>
+#include <QStandardPaths>
#include <QStatusBar>
#include <QTableView>
#include <QToolBar>
@@ -61,6 +65,73 @@ QString MainWindow::cidPrefixForIndex(int index)
return QStringLiteral("m%1").arg(index);
}
+QString MainWindow::uiStatePath()
+{
+ // GenericStateLocation, not StateLocation: the latter appends both the
+ // organization and the application name, and both are "qtmaildir" here,
+ // so it yields ~/.local/state/qtmaildir/qtmaildir. Built the same way
+ // Config::defaultPath() builds its own.
+ const QString base =
+ QStandardPaths::writableLocation(QStandardPaths::GenericStateLocation);
+ return base + QStringLiteral("/qtmaildir/uistate.conf");
+}
+
+void MainWindow::restoreUiState()
+{
+ QSettings state(uiStatePath(), QSettings::IniFormat);
+
+ // Every restore is conditional: an absent or rejected blob must leave the
+ // buildUi() defaults alone rather than produce a zero-size window.
+ const QByteArray geometry = state.value(QStringLiteral("window/geometry"))
+ .toByteArray();
+ if (!geometry.isEmpty()) {
+ restoreGeometry(geometry);
+ }
+
+ const QByteArray windowState = state.value(QStringLiteral("window/state"))
+ .toByteArray();
+ if (!windowState.isEmpty()) {
+ restoreState(windowState);
+ }
+
+ const QByteArray splitter = state.value(QStringLiteral("window/splitter"))
+ .toByteArray();
+ if (!splitter.isEmpty()) {
+ m_splitter->restoreState(splitter);
+ }
+
+ const QByteArray header = state.value(QStringLiteral("threadlist/header"))
+ .toByteArray();
+ if (!header.isEmpty()) {
+ m_threadView->horizontalHeader()->restoreState(header);
+ }
+
+ // The config value is the starting point for a profile that has never
+ // zoomed; once the user does, the state file is what they last had.
+ // clampZoom() rejects the garbage a hand-edited file can hold.
+ m_messageView->setZoomFactor(
+ state.value(QStringLiteral("message/zoom"), m_config.messageZoom())
+ .toDouble());
+}
+
+void MainWindow::saveUiState() const
+{
+ QDir().mkpath(QFileInfo(uiStatePath()).absolutePath());
+ QSettings state(uiStatePath(), QSettings::IniFormat);
+ state.setValue(QStringLiteral("window/geometry"), saveGeometry());
+ state.setValue(QStringLiteral("window/state"), saveState());
+ state.setValue(QStringLiteral("window/splitter"), m_splitter->saveState());
+ state.setValue(QStringLiteral("threadlist/header"),
+ m_threadView->horizontalHeader()->saveState());
+ state.setValue(QStringLiteral("message/zoom"), m_messageView->zoomFactor());
+}
+
+void MainWindow::closeEvent(QCloseEvent *event)
+{
+ saveUiState();
+ QMainWindow::closeEvent(event);
+}
+
MainWindow::MainWindow(const Config &config, QWidget *parent)
: QMainWindow(parent), m_config(config)
{
@@ -87,6 +158,9 @@ MainWindow::MainWindow(const Config &config, QWidget *parent)
buildUi();
registerActions();
buildMenus();
+ // After buildMenus(): QMainWindow::restoreState() matches toolbars by
+ // object name, so they must already exist or their position is dropped.
+ restoreUiState();
wireWorker();
showWarnings();
@@ -97,8 +171,12 @@ MainWindow::MainWindow(const Config &config, QWidget *parent)
// modifier shortcuts such as Ctrl+Q still work there, which the old
// filter blocked.
- if (!m_config.savedQueries().isEmpty()) {
- m_queryEdit->setText(m_config.savedQueries().first().query);
+ // Not savedQueries().first(): [queries] is read through childKeys(), which
+ // sorts alphabetically, so "first" means whatever happens to sort first
+ // rather than anything the user chose. Config resolves the name.
+ const SavedQuery startup = m_config.startupSavedQuery();
+ if (!startup.query.isEmpty()) {
+ m_queryEdit->setText(startup.query);
runCurrentQuery();
}
}
@@ -210,11 +288,11 @@ void MainWindow::buildUi()
connect(m_messageView, &MessageView::statusMessage,
this, [this](const QString &text) { m_statusLabel->setText(text); });
- auto *splitter = new QSplitter(Qt::Horizontal, central);
- splitter->addWidget(m_threadView);
- splitter->addWidget(m_messageView);
- splitter->setStretchFactor(1, 2);
- layout->addWidget(splitter, 1);
+ m_splitter = new QSplitter(Qt::Horizontal, central);
+ m_splitter->addWidget(m_threadView);
+ m_splitter->addWidget(m_messageView);
+ m_splitter->setStretchFactor(1, 2);
+ layout->addWidget(m_splitter, 1);
layout->addWidget(m_syncLog);
@@ -315,6 +393,32 @@ void MainWindow::registerActions()
tr("Load remote images for the current thread"), [this]() {
m_messageView->loadRemoteContent();
});
+ addAction(QStringLiteral("zoom_in"), tr("Zoom &in"),
+ tr("Enlarge the message text"), [this]() {
+ m_messageView->zoomIn();
+ });
+ addAction(QStringLiteral("zoom_out"), tr("Zoom &out"),
+ tr("Shrink the message text"), [this]() {
+ m_messageView->zoomOut();
+ });
+ auto *zoomReset =
+ addAction(QStringLiteral("zoom_reset"), tr("&Actual size"),
+ tr("Return the message text to its default size"), [this]() {
+ m_messageView->zoomReset();
+ });
+
+ // Ctrl+= alongside the configured binding: '=' reads as "back to normal",
+ // and on a layout where '+' is Shift+'=' it is the unshifted key next to
+ // zoom in. Appended rather than assigned, so a [keys] override of
+ // zoom_reset keeps working and simply gains this as a second way in.
+ // A user who bound Ctrl+= to something else in [keys] keeps their binding.
+ const QKeySequence altReset(QStringLiteral("Ctrl+="));
+ if (m_keyMap.actionFor(altReset).isEmpty()) {
+ QList<QKeySequence> shortcuts = zoomReset->shortcuts();
+ shortcuts.append(altReset);
+ zoomReset->setShortcuts(shortcuts);
+ }
+
addAction(QStringLiteral("undo"), tr("&Undo"),
tr("Undo the last tag change"), [this]() {
if (m_undoStack.canUndo())
@@ -362,6 +466,10 @@ void MainWindow::buildMenus()
viewMenu->addSeparator();
viewMenu->addAction(m_actions.value(QStringLiteral("toggle_html")));
viewMenu->addAction(m_actions.value(QStringLiteral("load_remote")));
+ viewMenu->addSeparator();
+ viewMenu->addAction(m_actions.value(QStringLiteral("zoom_in")));
+ viewMenu->addAction(m_actions.value(QStringLiteral("zoom_out")));
+ viewMenu->addAction(m_actions.value(QStringLiteral("zoom_reset")));
auto *helpMenu = menuBar()->addMenu(tr("&Help"));
auto *shortcuts = helpMenu->addAction(tr("&Keyboard shortcuts"));
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 4445894..f4186ff 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -38,6 +38,7 @@ class QLabel;
class QPushButton;
class QComboBox;
class QPlainTextEdit;
+class QSplitter;
class ThreadListModel;
class MessageView;
@@ -63,6 +64,15 @@ public:
/// cid: references from resolving to another's.
static QString cidPrefixForIndex(int index);
+ /// Path of the machine-written UI state file. Deliberately not
+ /// Config::defaultPath(): the config is hand-edited and must never gain a
+ /// base64 geometry blob, nor be rewritten on exit (QSettings does not
+ /// preserve comments or key order).
+ static QString uiStatePath();
+
+protected:
+ void closeEvent(QCloseEvent *event) override;
+
private slots:
void runCurrentQuery();
void onThreadsReady(const QVector<ThreadSummary> &threads, quint64 generation);
@@ -74,6 +84,12 @@ private slots:
private:
void buildUi();
+
+ /// Restores window geometry, splitter and thread-list header widths.
+ /// A missing or rejected blob leaves the buildUi() defaults in place.
+ void restoreUiState();
+ void saveUiState() const;
+
void registerActions();
void buildMenus();
void wireWorker();
@@ -116,6 +132,7 @@ private:
QLineEdit *m_queryEdit = nullptr;
QTableView *m_threadView = nullptr;
+ QSplitter *m_splitter = nullptr;
QComboBox *m_accountBox = nullptr;
QPushButton *m_syncButton = nullptr;
QLabel *m_statusLabel = nullptr;
diff --git a/src/messageview.cpp b/src/messageview.cpp
index aebb81b..9a1d3e4 100644
--- a/src/messageview.cpp
+++ b/src/messageview.cpp
@@ -21,8 +21,12 @@
#include <QDesktopServices>
#include <QHBoxLayout>
#include <QLabel>
+#include <QApplication>
+#include <QMouseEvent>
#include <QPushButton>
+#include <QtNumeric>
#include <QTimer>
+#include <QWheelEvent>
#include <QVBoxLayout>
#include <QWebEnginePage>
#include <QWebEngineProfile>
@@ -101,6 +105,13 @@ MessageView::MessageView(QWidget *parent)
settings->setAttribute(QWebEngineSettings::PluginsEnabled, false);
settings->setAttribute(QWebEngineSettings::FullScreenSupportEnabled, false);
+ // Ctrl+wheel zoom. The filter goes on the application rather than on
+ // m_view: the wheel event is delivered to an internal QQuickWidget the
+ // view creates lazily, so there is no child to filter at this point and a
+ // filter on m_view itself would never see it. eventFilter() narrows by
+ // ancestry, so no event outside this pane is touched.
+ qApp->installEventFilter(this);
+
m_headerLabel = new QLabel(this);
m_headerLabel->setTextFormat(Qt::RichText);
m_headerLabel->setWordWrap(true);
@@ -281,6 +292,88 @@ void MessageView::toggleHtml()
render();
}
+bool MessageView::eventFilter(QObject *watched, QEvent *event)
+{
+ const QEvent::Type type = event->type();
+ if (type != QEvent::Wheel && type != QEvent::MouseButtonPress)
+ return QWidget::eventFilter(watched, event);
+
+ // Application-wide filter: only events inside this pane are ours. Anything
+ // else, including a Ctrl+wheel over the thread list, passes untouched.
+ // isAncestorOf() is false for the widget itself, so test that separately.
+ auto *widget = qobject_cast<QWidget *>(watched);
+ if (!widget || (widget != m_view && !m_view->isAncestorOf(widget)))
+ return QWidget::eventFilter(watched, event);
+
+ if (type == QEvent::Wheel) {
+ auto *wheel = static_cast<QWheelEvent *>(event);
+ if (!(wheel->modifiers() & Qt::ControlModifier))
+ return QWidget::eventFilter(watched, event);
+
+ // angleDelta is in eighths of a degree; one detent is 120. A high
+ // resolution wheel sends smaller steps, so scale rather than treating
+ // every event as one full step.
+ const int delta = wheel->angleDelta().y();
+ if (delta != 0)
+ setZoomFactor(zoomFactor() + 0.1 * delta / 120.0);
+
+ // Consumed, or Chromium's own Ctrl+wheel zoom would run on top of
+ // ours and the factor we track would no longer be what is on screen.
+ return true;
+ }
+
+ // Ctrl+middle-click resets: the same hand that just zoomed with the wheel
+ // puts it back, without reaching for the keyboard.
+ auto *mouse = static_cast<QMouseEvent *>(event);
+ if (mouse->button() != Qt::MiddleButton
+ || !(mouse->modifiers() & Qt::ControlModifier)) {
+ return QWidget::eventFilter(watched, event);
+ }
+
+ zoomReset();
+
+ // Consumed: a plain middle click is paste-on-X11 in some contexts, and
+ // this gesture must do one thing only.
+ return true;
+}
+
+qreal MessageView::clampZoom(qreal factor)
+{
+ // qIsFinite rejects the NaN and infinity a corrupt or hand-edited state
+ // file can produce; qFuzzyIsNull rejects the 0.0 that a missing or
+ // non-numeric value converts to, which would render nothing at all.
+ if (!qIsFinite(factor) || factor <= 0.0)
+ return kDefaultZoom;
+ return qBound(kMinZoom, factor, kMaxZoom);
+}
+
+qreal MessageView::zoomFactor() const
+{
+ // The web view is the single source of truth. It keeps the factor across
+ // setHtml(), verified on Qt 6.11, so there is no second copy to drift.
+ return m_view->zoomFactor();
+}
+
+void MessageView::setZoomFactor(qreal factor)
+{
+ m_view->setZoomFactor(clampZoom(factor));
+}
+
+void MessageView::zoomIn()
+{
+ setZoomFactor(zoomFactor() + 0.1);
+}
+
+void MessageView::zoomOut()
+{
+ setZoomFactor(zoomFactor() - 0.1);
+}
+
+void MessageView::zoomReset()
+{
+ setZoomFactor(kDefaultZoom);
+}
+
void MessageView::loadRemoteContent()
{
// Applies to this thread only and is cleared by the next showThread().
diff --git a/src/messageview.h b/src/messageview.h
index 9570db5..09e7d71 100644
--- a/src/messageview.h
+++ b/src/messageview.h
@@ -65,13 +65,37 @@ public:
/// Tags of the thread on display, shown as chips along the bottom.
void setTags(const QStringList &tags);
+ /// The body zoom factor. Chromium's own range is roughly 0.25 to 5.0;
+ /// these are tighter, since a pane at either extreme is unusable and the
+ /// only visible way back is a menu entry the user cannot read.
+ static constexpr qreal kMinZoom = 0.5;
+ static constexpr qreal kMaxZoom = 3.0;
+ static constexpr qreal kDefaultZoom = 1.0;
+
+ /// Clamps to [kMinZoom, kMaxZoom]. A non-finite or non-positive value,
+ /// which is what a corrupt state file yields, falls back to kDefaultZoom.
+ static qreal clampZoom(qreal factor);
+
+ qreal zoomFactor() const;
+ void setZoomFactor(qreal factor);
+
public slots:
void toggleHtml();
void loadRemoteContent();
+ void zoomIn();
+ void zoomOut();
+ void zoomReset();
signals:
void statusMessage(const QString &text);
+protected:
+ /// Turns Ctrl+wheel over the body into zoom, and Ctrl+middle-click into a
+ /// reset. Both events are delivered to the web view's internal QQuickWidget
+ /// focus proxy, not to the view itself, so this filters the whole subtree
+ /// rather than one widget.
+ bool eventFilter(QObject *watched, QEvent *event) override;
+
private:
void render();
void updateHeader();