feat(queries): save a query from the UI, and split the buttons off the query row

Second half of item 23, on top of the storage change. A query can now be kept
without hand-editing a file, and the row of buttons no longer grows without
bound.

Ctrl+S opens a dialog on whatever is in the query bar, taking a name, an
optional account scope and whether the query is pinned. It preselects the
account already chosen in the dropdown, since that is the scope the user is
looking at, and it says so when a name is about to replace an existing query
rather than refusing the name: overwriting a saved query on purpose is a normal
edit, and the only thing worth preventing is doing it without noticing. Saving
over an entry keeps the stored entry's unknown fields rather than the dialog's
fresh value, so a field written by a later build survives being edited here.

The saved queries move to a row of their own beneath the query bar, pinned ones
as buttons and the rest behind a More queries menu that only exists when
something is in it. The ponytail note that stood in the query row predicted
exactly this: an unbounded list of buttons sharing the row squeezed the field.
Sent moves down with them and is still not a saved query, for the reason already
recorded there.

A saved query's account scope goes through the account DROPDOWN rather than
being baked into the query text. runQuery() already wraps the query in the
selected account's path, so pre-scoping here would apply it twice, and setting
the dropdown also shows the user which scope they are in. An unscoped query
clears the selection rather than inheriting whatever the last one left, which is
the same defect the rules preview had.

Seven tests, three mutations. Ignoring the pinned flag fails two of them,
pre-scoping the text instead of setting the dropdown fails two, and letting an
unscoped query inherit the previous account fails one. The menu-absence test
initially passed against no implementation at all, since it only asserted a
widget was missing; it now proves the row was populated first, which is the
guard that class of test needs.

Two existing invariants caught real omissions rather than needing adjustment:
every registered action must appear in KeyMap::knownActions(), which is what
gives it a configurable binding, and every action needs its own icon.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

1 files changed, 128 insertions, 0 deletions

diff --git a/src/savequerydialog.cpp b/src/savequerydialog.cpp
new file mode 100644
index 0000000..1ea97c2
--- /dev/null
+++ b/src/savequerydialog.cpp
@@ -0,0 +1,128 @@
+/*
+ * qtmaildir - a Qt6 mail client for notmuch-indexed Maildirs
+ * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "savequerydialog.h"
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QFormLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QVBoxLayout>
+
+bool SaveQueryDialog::namesAnExistingQuery(const Config &config,
+                                           const QString &name)
+{
+    for (const SavedQuery &saved : config.savedQueries()) {
+        if (saved.name.compare(name.trimmed(), Qt::CaseInsensitive) == 0)
+            return true;
+    }
+    return false;
+}
+
+SaveQueryDialog::SaveQueryDialog(const Config &config, const QString &query,
+                                 const QString &accountKey, QWidget *parent)
+    : QDialog(parent)
+    , m_config(config)
+{
+    setWindowTitle(tr("Save query"));
+
+    auto *layout = new QVBoxLayout(this);
+    auto *form = new QFormLayout;
+
+    m_name = new QLineEdit(this);
+    m_name->setObjectName(QStringLiteral("saveQueryName"));
+    m_name->setPlaceholderText(tr("A name for this query"));
+    form->addRow(tr("Name"), m_name);
+
+    m_query = new QLineEdit(query, this);
+    m_query->setObjectName(QStringLiteral("saveQueryQuery"));
+    form->addRow(tr("Query"), m_query);
+
+    // The scope is stored as an account KEY, so the entries carry the key as
+    // data exactly as the main window's dropdown does. "All accounts" is the
+    // empty key, not a missing entry, so an unscoped query is a real choice
+    // rather than the absence of one.
+    m_account = new QComboBox(this);
+    m_account->setObjectName(QStringLiteral("saveQueryAccount"));
+    m_account->addItem(tr("All accounts"), QString());
+    for (const Account &account : config.accounts())
+        m_account->addItem(account.key, account.key);
+    const int index = m_account->findData(accountKey);
+    m_account->setCurrentIndex(index >= 0 ? index : 0);
+    form->addRow(tr("Account"), m_account);
+
+    m_pinned = new QCheckBox(tr("Show as a button"), this);
+    m_pinned->setObjectName(QStringLiteral("saveQueryPinned"));
+    m_pinned->setChecked(true);
+    form->addRow(QString(), m_pinned);
+
+    layout->addLayout(form);
+
+    // Says what is about to happen rather than refusing the name. Overwriting
+    // a saved query on purpose is a normal edit, and the only thing worth
+    // preventing is doing it without noticing.
+    m_notice = new QLabel(this);
+    m_notice->setObjectName(QStringLiteral("saveQueryNotice"));
+    m_notice->setWordWrap(true);
+    layout->addWidget(m_notice);
+
+    auto *buttons = new QDialogButtonBox(
+        QDialogButtonBox::Save | QDialogButtonBox::Cancel, this);
+    connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
+    layout->addWidget(buttons);
+
+    m_ok = buttons->button(QDialogButtonBox::Save);
+    m_ok->setObjectName(QStringLiteral("saveQueryOk"));
+
+    connect(m_name, &QLineEdit::textChanged,
+            this, &SaveQueryDialog::updateOkState);
+    connect(m_query, &QLineEdit::textChanged,
+            this, &SaveQueryDialog::updateOkState);
+    updateOkState();
+
+    m_name->setFocus();
+}
+
+void SaveQueryDialog::updateOkState()
+{
+    const QString name = m_name->text().trimmed();
+    const bool usable = !name.isEmpty() && !m_query->text().trimmed().isEmpty();
+    m_ok->setEnabled(usable);
+
+    if (!name.isEmpty() && namesAnExistingQuery(m_config, name)) {
+        m_notice->setText(
+            tr("A saved query named '%1' already exists and will be "
+               "replaced.").arg(name));
+    } else {
+        m_notice->clear();
+    }
+}
+
+SavedQuery SaveQueryDialog::savedQuery() const
+{
+    SavedQuery saved;
+    saved.name = m_name->text().trimmed();
+    saved.query = m_query->text().trimmed();
+    saved.account = m_account->currentData().toString();
+    saved.pinned = m_pinned->isChecked();
+    return saved;
+}