1 files changed, 206 insertions, 0 deletions

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 0a9f9d8..792ba3f 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -325,6 +325,7 @@ void MainWindow::buildUi()
     // The status label is created first: the sync wiring below can report into
     // it before the rest of the UI exists.
     m_statusLabel = new QLabel(this);
+    m_statusLabel->setObjectName(QStringLiteral("statusMessage"));
     statusBar()->addWidget(m_statusLabel);
 
     // Beside the sync status rather than as a widget competing with it: the two
@@ -430,6 +431,15 @@ void MainWindow::buildUi()
         m_syncLog->appendPlainText(chunk.trimmed());
     });
 
+    // Syncs this window did not start. The user's cron runs the same script
+    // every ten minutes, so mail arrives and tags change while the window sits
+    // idle, and until now nothing here noticed.
+    m_syncMonitor = new SyncMonitor(SyncMonitor::defaultLockPath(),
+                                    QStringLiteral("/proc/locks"), this);
+    connect(m_syncMonitor, &SyncMonitor::stateChanged,
+            this, &MainWindow::onExternalSyncStateChanged);
+    m_syncMonitor->start();
+
     queryRow->addWidget(m_accountBox);
     queryRow->addWidget(m_queryEdit, 1);
     queryRow->addWidget(m_syncButton);
@@ -488,6 +498,16 @@ void MainWindow::buildUi()
             &QItemSelectionModel::currentRowChanged,
             this, &MainWindow::onThreadSelected);
 
+    // Separate from currentRowChanged: a selection can grow without current
+    // moving at all. Ctrl+click adds a row and leaves current where it was, and
+    // selectAll() emits no currentRowChanged whatsoever (verified against
+    // Qt 6.11). Both are multi-select gestures that have to blank the pane and
+    // cancel a pending mark-read, so neither can rely on the current-index
+    // signal to notice them.
+    connect(m_threadView->selectionModel(),
+            &QItemSelectionModel::selectionChanged,
+            this, &MainWindow::onSelectionChanged);
+
     m_messageView = new MessageView(central);
     m_messageView->setTagColors(&m_tagColors);
     connect(m_messageView, &MessageView::statusMessage,
@@ -659,6 +679,14 @@ void MainWindow::registerActions()
         m_queryEdit->setFocus();
         m_queryCompleter->triggerCompletion();
     });
+    addAction(QStringLiteral("select_all"), tr("Select &all threads"),
+              tr("Select every thread in the current result list"), [this]() {
+        // A registered action rather than the view's built-in SelectAll key, so
+        // it reaches the Edit menu, the shortcut reference and [keys] the same
+        // way every other binding does. That is the whole point: multi-select
+        // already worked, it was simply invisible.
+        m_threadView->selectAll();
+    });
     addAction(QStringLiteral("quit"), tr("&Quit"),
               tr("Quit qtmaildir"), [this]() { close(); });
 
@@ -680,6 +708,8 @@ void MainWindow::buildMenus()
     editMenu->addSeparator();
     editMenu->addAction(m_actions.value(QStringLiteral("focus_query")));
     editMenu->addAction(m_actions.value(QStringLiteral("complete_query")));
+    editMenu->addSeparator();
+    editMenu->addAction(m_actions.value(QStringLiteral("select_all")));
 
     auto *messageMenu = menuBar()->addMenu(tr("&Message"));
     messageMenu->addAction(m_actions.value(QStringLiteral("archive")));
@@ -731,6 +761,29 @@ void MainWindow::buildMenus()
             action->setIcon(icon);
     }
 
+    // Right-click on the thread list. Built from the same registered QActions
+    // as the menu bar, never from parallel copies: a [keys] override then shows
+    // the right shortcut here too, and an action cannot end up doing one thing
+    // from the menu bar and another from the context menu.
+    //
+    // Every entry applies to the whole selection already, since they all funnel
+    // through tagSelected(), so this needs no multi-row special casing.
+    m_threadContextMenu = new QMenu(this);
+    m_threadContextMenu->setObjectName(QStringLiteral("threadContextMenu"));
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("archive")));
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("delete")));
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("spam")));
+    m_threadContextMenu->addSeparator();
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("toggle_unread")));
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("flag")));
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("edit_tags")));
+    m_threadContextMenu->addSeparator();
+    m_threadContextMenu->addAction(m_actions.value(QStringLiteral("select_all")));
+
+    m_threadView->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(m_threadView, &QTableView::customContextMenuRequested,
+            this, &MainWindow::showThreadContextMenu);
+
     // The frequent subset only. A toolbar holding every action is as
     // unreadable as no toolbar.
     auto *toolBar = addToolBar(tr("Main"));
@@ -787,6 +840,18 @@ void MainWindow::showShortcutReference()
                       "</tr></table>")
                        .arg(left, right));
 
+    // Mouse selection is view behaviour, not an action, so it cannot appear in
+    // the table above however the table is generated. Said here because it is
+    // otherwise undiscoverable: nothing in the UI hints that a thread list
+    // takes more than one row at a time.
+    auto *selectionNote = new QLabel(
+        tr("<b>Thread list:</b> <tt>Ctrl</tt>+click adds or removes a single "
+           "row, <tt>Shift</tt>+click extends the selection to a range. Tag, "
+           "archive and delete all apply to every selected thread."),
+        &dialog);
+    selectionNote->setTextFormat(Qt::RichText);
+    selectionNote->setWordWrap(true);
+
     auto *note = new QLabel(
         tr("Rebind any of these in the <tt>[keys]</tt> section of "
            "<tt>qtmaildir.conf</tt>, using the action name."),
@@ -799,6 +864,7 @@ void MainWindow::showShortcutReference()
 
     auto *layout = new QVBoxLayout(&dialog);
     layout->addWidget(label);
+    layout->addWidget(selectionNote);
     layout->addWidget(note);
     layout->addStretch();
     layout->addWidget(buttons);
@@ -973,12 +1039,94 @@ void MainWindow::onQueryFinished(int total, quint64 generation)
     m_statusLabel->setText(tr("%n thread(s)", "", total));
 }
 
+void MainWindow::showThreadContextMenu(const QPoint &pos)
+{
+    const QModelIndex index = m_threadView->indexAt(pos);
+    if (!index.isValid())
+        return;   // Right-click on empty space below the rows.
+
+    // Right-clicking a row that is already part of the selection must leave
+    // that selection alone: the actions apply to every selected thread, so
+    // collapsing to the clicked row here would silently narrow a deliberate
+    // multi-row selection to one. Right-clicking outside it selects that row
+    // instead, which is what every other list does.
+    if (!m_threadView->selectionModel()->isRowSelected(index.row()))
+        m_threadView->selectRow(index.row());
+
+    m_threadContextMenu->popup(m_threadView->viewport()->mapToGlobal(pos));
+}
+
+void MainWindow::onSelectionChanged()
+{
+    const int selected = m_threadView->selectionModel()->selectedRows().size();
+    if (selected <= 1) {
+        // Clearing the count here would wipe whatever the last action reported
+        // ("Archive: 3 threads"), which is the more useful message once the
+        // selection is gone. Only a count this function wrote is taken back.
+        if (m_statusLabel->text() == m_selectionMessage)
+            m_statusLabel->clear();
+        m_selectionMessage.clear();
+
+        // Collapsing a multi-row selection back to one row has to load that
+        // row here, and cannot be left to onThreadSelected. currentRowChanged
+        // is emitted BEFORE the selection model is updated (verified against
+        // Qt 6.11), so when a click collapses three rows to one, that handler
+        // still sees three selected, takes the multi-select branch and returns
+        // without loading anything. Only this signal sees the real count.
+        const QModelIndex current = m_threadView->currentIndex();
+        if (current.isValid()
+            && m_model->threadAt(current.row()).threadId != m_currentThreadId) {
+            onThreadSelected(current, QModelIndex());
+        }
+        return;
+    }
+
+    // The count is the part that actually teaches multi-select: it acknowledges
+    // the selection while it is being built, rather than only after an action
+    // has already been applied to it.
+    m_selectionMessage = tr("%n thread(s) selected", "", selected);
+    m_statusLabel->setText(m_selectionMessage);
+
+    // Ctrl+click and selectAll() reach a multi-row selection without moving
+    // current, so onThreadSelected never runs and its guard never fires. The
+    // pane and the pending timer have to be dealt with here as well.
+    m_markReadTimer->stop();
+    m_markReadThreadId.clear();
+    m_currentThreadId.clear();
+    m_messageView->clear();
+}
+
 void MainWindow::onThreadSelected(const QModelIndex &current,
                                   const QModelIndex &)
 {
     if (!current.isValid())
         return;
 
+    // A selection spanning more than one row is aimed at a bulk action, not at
+    // reading. current follows the keyboard cursor as the selection extends, so
+    // without this every row swept through would be rendered and, worse,
+    // queued to be marked read: a selection gesture must not mutate mail.
+    //
+    // The count read here is deliberately not trusted on its own. This signal
+    // is emitted BEFORE the selection model is updated (verified against
+    // Qt 6.11), so a Ctrl+click that takes the selection from one row to two
+    // arrives here still reporting one. onSelectionChanged() always follows and
+    // sees the true count, and it is what finally blanks the pane and cancels
+    // the timer; this branch only catches the case where the count is already
+    // stale in the other direction.
+    //
+    // The stop() is not redundant with the guard. Clicking one row arms a timer
+    // legitimately and only then does the selection grow, so the timer already
+    // running for that first row has to be cancelled here or it fires behind a
+    // pane that no longer shows the thread.
+    if (m_threadView->selectionModel()->selectedRows().size() > 1) {
+        m_markReadTimer->stop();
+        m_markReadThreadId.clear();
+        m_currentThreadId.clear();
+        m_messageView->clear();
+        return;
+    }
+
     const ThreadSummary thread = m_model->threadAt(current.row());
     m_currentThreadId = thread.threadId;
     m_messageView->setTags(thread.tags);
@@ -995,6 +1143,14 @@ void MainWindow::onThreadLoaded(const QVector<MessageRef> &messages,
     if (generation != m_generation || messages.isEmpty())
         return;
 
+    // A load started while the selection was still a single row can land after
+    // it has grown: loadThread crosses to the worker on a queued connection, so
+    // the reply arrives after onSelectionChanged() has already blanked the
+    // pane. Without this it would paint a thread back over the blank, and the
+    // pane would only look right once a third row made the count stale-proof.
+    if (m_threadView->selectionModel()->selectedRows().size() > 1)
+        return;
+
     MimeParser parser;
     QList<ThreadRenderItem> items;
     items.reserve(messages.size());
@@ -1084,6 +1240,12 @@ void MainWindow::onSyncFinished(bool success, int exitCode)
         // A sync is the usual way new tags enter the database.
         requestAllTags();
     } else if (exitCode == kSyncSkippedExitCode) {
+        // Skipped means the lock was never ours: some other run holds it. If
+        // both started inside the same poll interval the monitor will have
+        // latched this lock period as local, which would swallow the report
+        // when that other run finishes. Hand it back.
+        m_localSyncHoldsLock = false;
+
         // Not a failure: another run holds the lock and is doing the work.
         // The user's cron fires every ten minutes, so a click landing inside
         // one is routine and must not raise an error or the log pane.
@@ -1142,6 +1304,50 @@ void MainWindow::onTagsApplied(const TagChange &change)
     }
 }
 
+void MainWindow::onExternalSyncStateChanged(SyncMonitor::State state)
+{
+    if (state == SyncMonitor::State::Running) {
+        // A sync this window started is already reported by setSyncBusy().
+        // Remember that this particular lock period is ours, because the
+        // release at the end of it must be ignored too: the process exits, and
+        // therefore isRunning() goes false, BEFORE the monitor's next poll sees
+        // the lock gone. Testing isRunning() again on that poll would report a
+        // local sync as an external one, stamping "background sync completed"
+        // over the local run's own result up to two seconds later.
+        m_localSyncHoldsLock = (m_sync && m_sync->isRunning());
+        if (m_localSyncHoldsLock)
+            return;
+
+        m_syncProgress->setVisible(true);
+        m_statusLabel->setText(tr("Background sync running..."));
+        return;
+    }
+
+    // The release of a lock this window took. onSyncFinished() has already
+    // said what happened, including for a failure, so there is nothing to add.
+    if (m_localSyncHoldsLock) {
+        m_localSyncHoldsLock = false;
+        return;
+    }
+
+    m_syncProgress->setVisible(false);
+
+    // Deliberately reports rather than refreshes. runCurrentQuery() clears the
+    // undo stack, the selection and the message pane, which is right for a
+    // query the user typed and hostile for one fired by a cron timer: with a
+    // sync every ten minutes it would discard undo history and close the thread
+    // being read, up to six times an hour, with no action from the user.
+    //
+    // Unknown is not worth reporting either. It means the lock table could not
+    // be read, so nothing was observed, and "sync finished" would be a claim
+    // this cannot support.
+    if (state == SyncMonitor::State::Idle) {
+        m_statusLabel->setText(
+            tr("Background sync completed. Press Enter in the query bar to "
+               "refresh."));
+    }
+}
+
 void MainWindow::setSyncBusy(bool busy)
 {
     m_syncProgress->setVisible(busy);