aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/mainwindow.cpp179
-rw-r--r--src/mainwindow.h44
-rw-r--r--src/messageview.cpp86
-rw-r--r--src/messageview.h37
-rw-r--r--src/threaddashboard.cpp3
5 files changed, 348 insertions, 1 deletions
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 4cce042..321c608 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -69,6 +69,7 @@
#include "pendingchangesdialog.h"
#include "savequerydialog.h"
#include "tagrulesdialog.h"
+#include "threaddashboard.h"
#include "threadlistmodel.h"
#include "threadlistview.h"
#include "version.h"
@@ -960,6 +961,44 @@ void MainWindow::buildUi()
connect(m_messageView, &MessageView::searchRequested,
this, &MainWindow::runSearchFromPane);
+ // The conversation dashboard (item 177). Its colours are the application's
+ // own, so the strip it holds reads the same table every other chip does.
+ ThreadDashboard *dashboard = m_messageView->dashboard();
+ dashboard->setTagColors(&m_tagColors);
+
+ // An unread entry is a way INTO the conversation: expand the thread and
+ // select that message, which is the ordinary gesture rather than a second
+ // way to open a message.
+ connect(dashboard, &ThreadDashboard::messageActivated,
+ this, &MainWindow::selectMessageInCurrentThread);
+
+ // The "+N more" link. The full list already lives in the left pane, so
+ // this expands the thread there and leaves the selection alone.
+ connect(dashboard, &ThreadDashboard::expandRequested, this, [this]() {
+ const QModelIndex current = m_threadView->currentIndex();
+ if (current.isValid() && !m_model->isMessageRow(current))
+ m_threadView->expand(current);
+ });
+
+ // The three buttons TRIGGER the existing actions rather than reimplement
+ // them. Those actions already resolve their scope from the selection, and
+ // a conversation row resolves to the whole conversation, which is exactly
+ // what a button on this pane means. A second path to the same write is the
+ // mistake the deleted "Whole thread" submenu made.
+ //
+ // Looked up at emit time: registerActions() runs after buildUi(), so the
+ // map is empty here.
+ const auto triggerAction = [this](const QString &name) {
+ if (QAction *action = m_actions.value(name))
+ action->trigger();
+ };
+ connect(dashboard, &ThreadDashboard::markAllReadRequested, this,
+ [triggerAction]() { triggerAction(QStringLiteral("mark_all_read")); });
+ connect(dashboard, &ThreadDashboard::archiveRequested, this,
+ [triggerAction]() { triggerAction(QStringLiteral("archive")); });
+ connect(dashboard, &ThreadDashboard::deleteRequested, this,
+ [triggerAction]() { triggerAction(QStringLiteral("delete")); });
+
m_splitter = new QSplitter(Qt::Horizontal, central);
m_splitter->addWidget(m_threadView);
m_splitter->addWidget(m_messageView);
@@ -2558,6 +2597,8 @@ void MainWindow::wireWorker()
this, &MainWindow::onThreadTreeLoaded);
connect(m_worker, &NotmuchWorker::messageLoaded,
this, &MainWindow::onMessageLoaded);
+ connect(m_worker, &NotmuchWorker::threadDigestLoaded,
+ this, &MainWindow::onThreadDigestLoaded);
connect(m_worker, &NotmuchWorker::errorOccurred,
this, &MainWindow::onWorkerError);
connect(m_worker, &NotmuchWorker::allTagsReady,
@@ -4063,6 +4104,52 @@ void MainWindow::onThreadSelected(const QModelIndex &current,
m_currentThreadId = thread.threadId;
m_messageView->setTags(thread.tags);
+ // A CONVERSATION row stands for the whole thread, so there is no single
+ // message to render and the pane shows the conversation instead (item
+ // 177). A thread of one message is not a conversation and falls through to
+ // the message path below, which is the case the whole split protects: it
+ // must still open on one click.
+ if (m_model->isConversationRow(current)) {
+ // No mark-read, deliberately: the row displays nothing, so there is no
+ // message the user can be said to have read. Any timer armed for the
+ // row they came from is still cancelled.
+ m_markReadTimer->stop();
+ m_markReadMessageId.clear();
+
+ m_currentMessageId.clear();
+ m_currentMessageThreadId.clear();
+
+ m_dashboardThreadId = thread.threadId;
+
+ // The heading before the round trip, not after it: the subject, the
+ // account and the tags are already on the summary, and the digest
+ // carries none of them. Waiting would show an empty heading for as
+ // long as the worker takes.
+ m_messageView->setDashboardThread(
+ thread.subject,
+ m_model->data(current, ThreadListModel::AccountLabelRole).toString(),
+ thread.tags);
+
+ // Empty for now, so the pane switches at once rather than staying on
+ // the previous message until the digest lands.
+ ThreadDigest pending;
+ pending.threadId = thread.threadId;
+ pending.totalCount = thread.totalCount;
+ m_messageView->showDashboard(pending);
+
+ // Its OWN generation. m_generation is the query's, and bumping that
+ // discards any thread load in flight and blanks the pane, which is the
+ // opposite of what selecting a row should do.
+ ++m_digestGeneration;
+ QMetaObject::invokeMethod(m_worker, "loadThreadDigest",
+ Qt::QueuedConnection,
+ Q_ARG(QString, thread.threadId),
+ Q_ARG(quint64, m_digestGeneration));
+ return;
+ }
+
+ m_dashboardThreadId.clear();
+
// The message the card displays, not the thread. The summary's `unread` is
// a union over the conversation, so this can arm for a thread whose first
// message is already read; the write is scoped to that message either way,
@@ -4100,6 +4187,32 @@ void MainWindow::onThreadSelected(const QModelIndex &current,
Q_ARG(quint64, m_generation));
}
+void MainWindow::onThreadDigestLoaded(const ThreadDigest &digest,
+ quint64 generation)
+{
+ // Three guards, and each one covers a different way the answer can outlive
+ // the selection that asked for it. loadThreadDigest crosses on a queued
+ // connection, so all of them are reachable by moving the selection while
+ // one is in flight.
+ //
+ // Superseded by a later request: the user moved to another conversation.
+ if (generation != m_digestGeneration)
+ return;
+
+ // The pane is no longer showing a dashboard at all: it was blanked, or a
+ // message row was selected. Every route that renders a message switches
+ // the stack back, so this is the question rather than a flag of our own.
+ if (!m_messageView->showingDashboard())
+ return;
+
+ // And it is showing a DIFFERENT conversation. The generation guard alone
+ // would let this through if a request were ever made without bumping it.
+ if (digest.threadId != m_dashboardThreadId)
+ return;
+
+ m_messageView->showDashboard(digest);
+}
+
void MainWindow::onMessageLoaded(const QVector<MessageRef> &messages,
quint64 generation)
{
@@ -4217,6 +4330,9 @@ void MainWindow::onThreadTreeLoaded(const QVector<MessageNode> &nodes,
// A stale-thread recovery waits for exactly this: the message it wants to
// select does not exist as a row until the replies land.
applyPendingRecovery();
+
+ // And so does a dashboard entry, for the same reason.
+ applyPendingDashboardSelection();
}
void MainWindow::renderMessages(const QVector<MessageRef> &messages)
@@ -4761,6 +4877,69 @@ void MainWindow::onRowDoubleClicked(const QModelIndex &index)
recoverStaleThread(threadId, messageId);
}
+void MainWindow::selectMessageInCurrentThread(const QString &messageId)
+{
+ if (messageId.isEmpty())
+ return;
+
+ const QModelIndex current = m_threadView->currentIndex();
+ if (!current.isValid() || m_model->isMessageRow(current))
+ return;
+
+ // Expanded FIRST, and unconditionally: this is also what asks the worker
+ // for the replies, so a collapsed thread has no row to select yet.
+ m_threadView->expand(current);
+
+ m_dashboardSelectThreadId = m_model->threadFor(current).threadId;
+ m_dashboardSelectMessageId = messageId;
+ applyPendingDashboardSelection();
+}
+
+void MainWindow::applyPendingDashboardSelection()
+{
+ if (m_dashboardSelectMessageId.isEmpty())
+ return;
+
+ for (int row = 0; row < m_model->rowCount(QModelIndex()); ++row) {
+ const QModelIndex thread = m_model->index(row, 0, QModelIndex());
+ if (m_model->threadAt(row).threadId != m_dashboardSelectThreadId)
+ continue;
+
+ // The thread's first message is the ROOT row, not a child:
+ // setThreadMessages drops depth 0 because the root stands for it, so
+ // looking for it among the children finds nothing.
+ if (m_model->data(thread, ThreadListModel::MessageIdRole).toString()
+ == m_dashboardSelectMessageId) {
+ selectRowAt(thread);
+ m_dashboardSelectMessageId.clear();
+ m_dashboardSelectThreadId.clear();
+ return;
+ }
+
+ for (int child = 0; child < m_model->rowCount(thread); ++child) {
+ const QModelIndex reply = m_model->index(child, 0, thread);
+ if (m_model->messageAt(reply).messageId
+ != m_dashboardSelectMessageId)
+ continue;
+ selectRowAt(reply);
+ m_dashboardSelectMessageId.clear();
+ m_dashboardSelectThreadId.clear();
+ return;
+ }
+
+ // The replies have not arrived. The target stays remembered and
+ // onThreadTreeLoaded() runs this again when they do; the selection is
+ // deliberately left where it is until then, so the dashboard the user
+ // clicked from stays on screen rather than flashing to something else.
+ return;
+ }
+
+ // The thread is not in the list at all, which the query having moved on
+ // would produce. Nothing to select, and nothing to keep waiting for.
+ m_dashboardSelectMessageId.clear();
+ m_dashboardSelectThreadId.clear();
+}
+
void MainWindow::applyPendingRecovery()
{
if (m_recoverThreadId.isEmpty())
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 11f35e7..16bf8c4 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -41,6 +41,7 @@
#include "tagrules.h"
#include "syncmonitor.h"
#include "tagcolors.h"
+#include "threaddigest.h"
#include "types.h"
// Held by value: the parsed business-senders list is a member, and the load is
@@ -585,6 +586,22 @@ private slots:
/// Selects the remembered message once its thread's rows have loaded.
void applyPendingRecovery();
+
+ /// Selects \p messageId inside the currently selected conversation,
+ /// expanding it first (item 177).
+ ///
+ /// For the dashboard's unread entries. Deliberately NOT recoverStaleThread(),
+ /// which runs thread:<id> as a new query: the thread is already in the list
+ /// the user is looking at, and replacing that list to reach a row it
+ /// already holds would throw away the view they came from.
+ ///
+ /// A reply row does not exist until the expansion's replies arrive, so the
+ /// target is remembered and applied again when they do.
+ void selectMessageInCurrentThread(const QString &messageId);
+
+ /// Applies a pending selectMessageInCurrentThread() target, if any.
+ void applyPendingDashboardSelection();
+
void onThreadsReady(const QVector<ThreadSummary> &threads, quint64 generation);
void onQueryFinished(int total, quint64 generation);
void onThreadSelected(const QModelIndex &current, const QModelIndex &previous);
@@ -609,6 +626,15 @@ private slots:
/// Renders the single message a message row asked for.
void onMessageLoaded(const QVector<MessageRef> &messages,
quint64 generation);
+
+ /// Fills the conversation dashboard once the worker has read the digest.
+ ///
+ /// Guarded the way onMessageLoaded() is, and for the same reason: the
+ /// request crosses on a queued connection, so the answer arrives after
+ /// whatever the user did in the meantime. A digest for a thread the pane
+ /// has moved off, or one that arrives once the pane is showing a message,
+ /// must not repaint anything.
+ void onThreadDigestLoaded(const ThreadDigest &digest, quint64 generation);
void onWorkerError(const QString &message);
void onSyncFinished(bool success, int exitCode);
@@ -1601,6 +1627,24 @@ private:
QString m_lastQuery;
QString m_currentThreadId;
+ /// The digest request's own generation, bumped per request.
+ ///
+ /// Separate from m_generation, which is the QUERY generation: bumping that
+ /// one discards any thread load in flight and blanks the pane, so a
+ /// selection asking for a digest would cancel the work the selection
+ /// itself started.
+ quint64 m_digestGeneration = 0;
+
+ /// The thread the dashboard is showing, empty whenever it is not showing.
+ /// A late digest is matched against this, not against m_currentThreadId,
+ /// which is also set for a thread of one message that renders normally.
+ QString m_dashboardThreadId;
+
+ /// The message a dashboard entry asked for and the thread it is in, both
+ /// empty when nothing is waiting. See selectMessageInCurrentThread().
+ QString m_dashboardSelectMessageId;
+ QString m_dashboardSelectThreadId;
+
/// The message a MESSAGE row is showing, empty whenever the pane holds a
/// whole thread. The two are mutually exclusive and each clears the other,
/// so a late reply can tell which kind of selection it belongs to.
diff --git a/src/messageview.cpp b/src/messageview.cpp
index eb0dccd..7106ab5 100644
--- a/src/messageview.cpp
+++ b/src/messageview.cpp
@@ -31,6 +31,7 @@
#include <QMenu>
#include <QMouseEvent>
#include <QPushButton>
+#include <QStackedWidget>
#include <QStandardPaths>
#include <QtNumeric>
#include <QResizeEvent>
@@ -57,6 +58,7 @@
#include "searchterm.h"
#include "tagstrip.h"
#include "threadcidmap.h"
+#include "threaddashboard.h"
#include "version.h"
namespace {
@@ -444,6 +446,11 @@ MessageView::MessageView(QWidget *parent)
// Tags live under the message rather than in the thread list, where
// spelling them out cost most of the list's width.
m_tagStrip = new TagStrip(this);
+ // Named because the pane now holds TWO strips: this one, under the
+ // message, and the dashboard's, under the conversation heading. An
+ // unqualified findChild<TagStrip *>() cannot tell them apart, and which
+ // one it happens to return is an ordering accident.
+ m_tagStrip->setObjectName(QStringLiteral("messageTagStrip"));
m_tagStrip->hide();
// Item 85: a tag chip is searchable. The strip reports which chip was hit
@@ -475,7 +482,12 @@ MessageView::MessageView(QWidget *parent)
// Left at the style's own default until then, which is what a MessageView
// built on its own in a test gets.
- auto *layout = new QVBoxLayout(this);
+ // Everything above belongs to ONE of the pane's two faces. The message
+ // page carries it; the dashboard is the other page of the stack.
+ m_messagePage = new QWidget(this);
+ m_messagePage->setObjectName(QStringLiteral("messagePage"));
+ auto *layout = new QVBoxLayout(m_messagePage);
+ layout->setContentsMargins(0, 0, 0, 0);
layout->addLayout(headerRow);
layout->addWidget(m_blockedBar);
layout->addWidget(m_receiveOnlyRibbon);
@@ -489,6 +501,27 @@ MessageView::MessageView(QWidget *parent)
layout->addWidget(m_attachmentBar);
layout->addWidget(m_tagStrip);
+ m_dashboard = new ThreadDashboard(this);
+
+ // A QStackedWidget takes the LARGEST minimum of its pages, so the hidden
+ // dashboard would set the floor for the whole pane: its three action
+ // buttons side by side measured 395px, against the 300px MainWindow asks
+ // for, and a floor the pane cannot go under is a floor that squeezes the
+ // thread list instead. The dashboard already scrolls, so letting it be
+ // narrower than its natural width costs nothing it does not already
+ // handle.
+ m_dashboard->setMinimumWidth(0);
+ m_dashboard->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
+
+ m_stack = new QStackedWidget(this);
+ m_stack->addWidget(m_messagePage);
+ m_stack->addWidget(m_dashboard);
+ m_stack->setCurrentWidget(m_messagePage);
+
+ auto *outer = new QVBoxLayout(this);
+ outer->setContentsMargins(0, 0, 0, 0);
+ outer->addWidget(m_stack);
+
applyNoticeBarStyles();
clear();
@@ -519,9 +552,57 @@ void MessageView::setDocument(const QString &html)
m_view->setHtml(html, documentUrl());
}
+bool MessageView::showingDashboard() const
+{
+ return m_stack && m_stack->currentWidget() == m_dashboard;
+}
+
+void MessageView::showMessagePage()
+{
+ if (m_stack)
+ m_stack->setCurrentWidget(m_messagePage);
+}
+
+void MessageView::setDashboardThread(const QString &subject,
+ const QString &accountLabel,
+ const QStringList &tags)
+{
+ m_dashboard->setThreadHeading(subject, accountLabel);
+ m_dashboard->setTags(tags);
+}
+
+void MessageView::showDashboard(const ThreadDigest &digest)
+{
+ // Everything the message page was serving is dropped, exactly as
+ // showPlaceholder() drops it: the pane is no longer displaying that
+ // message, so none of its parts may stay reachable behind the dashboard.
+ m_items.clear();
+ m_tagStrip->setTags({});
+ m_cidHandler->setParts({});
+ m_interceptor->setAllowedCids({});
+ m_interceptor->resetForNewMessage();
+
+ m_headerLabel->clear();
+ m_detailsButton->hide();
+ m_blockedBar->hide();
+ m_messageBar->hide();
+ rebuildAttachmentBar();
+ setStaleThread(QString(), QString());
+
+ // Not the placeholder: a helper link is honoured only while THAT is on
+ // screen, and this is a different pane.
+ m_showingPlaceholder = false;
+ setDocument(QString());
+
+ m_dashboard->setDigest(digest);
+ m_stack->setCurrentWidget(m_dashboard);
+}
+
void MessageView::showPlaceholder(
const QList<HtmlBuilder::PlaceholderHelper> &helpers)
{
+ showMessagePage();
+
// Everything clear() drops, dropped again: this is reachable directly and
// must not leave a previous thread's parts serveable behind the logo.
m_items.clear();
@@ -633,6 +714,7 @@ void MessageView::setBarActions(const QList<QAction *> &messageActions,
void MessageView::clear()
{
+ showMessagePage();
m_items.clear();
m_showingPlaceholder = false;
m_tagStrip->setTags({});
@@ -668,6 +750,7 @@ void MessageView::clear()
void MessageView::showThread(const QList<ThreadRenderItem> &items)
{
+ showMessagePage();
m_items = items;
m_preferHtml = true;
m_showingPlaceholder = false;
@@ -707,6 +790,7 @@ void MessageView::showThread(const QList<ThreadRenderItem> &items)
void MessageView::showError(const QString &text, const QString &filePath)
{
+ showMessagePage();
m_items.clear();
m_showingPlaceholder = false;
diff --git a/src/messageview.h b/src/messageview.h
index c81a4f6..10b9430 100644
--- a/src/messageview.h
+++ b/src/messageview.h
@@ -29,10 +29,13 @@
#include "marks.h"
#include "mimeparser.h"
#include "searchterm.h"
+#include "threaddigest.h"
class QLabel;
class QMenu;
+class QStackedWidget;
class QToolBar;
+class ThreadDashboard;
class QWebEnginePage;
class QPushButton;
class QWebEngineView;
@@ -123,6 +126,29 @@ public:
/// re-render it with fresh counts without guessing what is on screen.
bool showingPlaceholder() const { return m_showingPlaceholder; }
+ /// Shows the conversation dashboard instead of a message (item 177).
+ ///
+ /// A thread row stands for the conversation, so there is no single message
+ /// to render. The heading, account and tags come from the summary and are
+ /// set separately: the digest is built from the index by the worker and
+ /// carries none of them.
+ void showDashboard(const ThreadDigest &digest);
+
+ /// The heading the dashboard displays. Separate from showDashboard()
+ /// because the summary is known at selection time and the digest arrives
+ /// afterwards, so the pane can be right before the round trip returns.
+ void setDashboardThread(const QString &subject, const QString &accountLabel,
+ const QStringList &tags);
+
+ /// True while the dashboard is what the pane is showing.
+ ///
+ /// The pane's content is asserted through this and through the dashboard's
+ /// own accessors, never by rendering: see "Rendering probes lie".
+ bool showingDashboard() const;
+
+ /// The dashboard itself, so the window can connect its signals. Never null.
+ ThreadDashboard *dashboard() const { return m_dashboard; }
+
/// Supplies the tag strip's colours. Not owned; must outlive the view.
void setTagColors(const TagColors *colours);
@@ -410,6 +436,17 @@ private:
/// Gates queryRequested(), so a link in a message body cannot run a query.
bool m_showingPlaceholder = false;
+ /// The two things this pane can be: a message, or the conversation it
+ /// belongs to. A stack rather than show/hide over eight widgets, so
+ /// switching cannot leave half of one pane visible behind the other.
+ QStackedWidget *m_stack = nullptr;
+ QWidget *m_messagePage = nullptr;
+ ThreadDashboard *m_dashboard = nullptr;
+
+ /// Puts the message page back on top. Every route that renders a message
+ /// passes through it, so the dashboard cannot survive into a message.
+ void showMessagePage();
+
QWebEngineProfile *m_profile = nullptr;
QWebEngineView *m_view = nullptr;
RequestInterceptor *m_interceptor = nullptr;
diff --git a/src/threaddashboard.cpp b/src/threaddashboard.cpp
index 8583379..56b587f 100644
--- a/src/threaddashboard.cpp
+++ b/src/threaddashboard.cpp
@@ -197,6 +197,9 @@ ThreadDashboard::ThreadDashboard(QWidget *parent) : QWidget(parent)
// Block 2: the tag chips. One tier, no muting, drawn by the same strip the
// message pane uses so the two cannot drift.
m_tags = new TagStrip;
+ // Named for the same reason the message pane's is: the two sit in one
+ // widget tree and an unqualified findChild cannot tell them apart.
+ m_tags->setObjectName(QStringLiteral("dashboardTagStrip"));
layout->addWidget(m_tags);
// Block 3: the counts, with the read-progress bar beneath.