fix(view): stop clipping the date, and make the accent bar visible

Both found by rendering real cards to an image and looking at them, not by any
assertion. The suite was green through both.

The date lost the leading digit of its year on every UNREAD card. The layout
reserves the date's width from the font it is handed, which is the view's
regular font, while the delegate paints with the bold one the model supplies for
unread: 154px reserved against 170px needed. CardLayout now measures the date
bold whatever font it is given, so the reserved width cannot be narrower than
what is drawn. A few pixels are wasted on a read card, which is the cheap side of
the trade.

The accent bar was painted correctly and was invisible. Blending the account
colour 0.35 toward the palette's Base, as the plan specified, is a fraction OF
THE ACCOUNT COLOUR, so on a dark theme it produced (0.18, 0.22, 0.26) against a
Base of (0.169, 0.169, 0.169): the background. The blend is dropped entirely.
An account colour is already chosen to be a chip's fill carrying legible text,
so it is muted to begin with, and nothing is drawn on the bar that needs that
contrast. The spine keeps a blend, at 0.55, because it runs the full height of
every reply in an expansion and is a different problem from a 3px edge marker.

The bar is still faint at 3px on a dark theme, since the account colours are
chosen as chip fills. Whether kAccentWidth needs raising cannot be settled
without the user's own accounts, screen and theme; that is Task 10's open
question and it is left open.

4 files changed, 93 insertions, 25 deletions

diff --git a/src/carddelegate.cpp b/src/carddelegate.cpp
index bc03b5a..a3a846d 100644
--- a/src/carddelegate.cpp
+++ b/src/carddelegate.cpp
@@ -53,15 +53,21 @@ QColor CardDelegate::accentLineColour(const QColor &accountColour)
     if (!accountColour.isValid())
         return ThreadListModel::threadLineColour();
 
-    // The same 0.35 weight threadLineColour() uses, toward Base rather than
-    // toward Text, so the two kinds of line sit at the same visual strength.
-    const QColor base = QGuiApplication::palette().color(QPalette::Base);
-    constexpr qreal kWeight = 0.35;
-    const qreal inverse = 1.0 - kWeight;
-    return QColor::fromRgbF(
-        accountColour.redF() * kWeight + base.redF() * inverse,
-        accountColour.greenF() * kWeight + base.greenF() * inverse,
-        accountColour.blueF() * kWeight + base.blueF() * inverse);
+    // 0.35 toward Base was the first attempt and produced an INVISIBLE bar on
+    // a dark theme: rendered against a Base of (0.169, 0.169, 0.169) it landed
+    // at (0.18, 0.22, 0.26), which is the background. The weight is a fraction
+    // OF THE ACCOUNT COLOUR, so a low one keeps the background, not the hue.
+    //
+    // The bar is the account's colour, undiluted. Blending it toward Base at
+    // all was the mistake: a chip's colour is chosen to carry text on top and
+    // is therefore already muted, and three pixels of a muted colour on a dark
+    // background is nothing at all. There is no text on this bar, so nothing
+    // needs the contrast a chip's fill was picked for.
+    //
+    // What DOES step back is the spine, below: a line running the height of a
+    // whole expansion has to be followable without competing with the senders
+    // beside it, which is a different problem from a 3px edge marker.
+    return accountColour;
 }
 
 QSize CardDelegate::sizeHint(const QStyleOptionViewItem &option,
@@ -110,10 +116,22 @@ void CardDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
     if (!card.accentRect.isEmpty())
         painter->fillRect(card.accentRect, lineColour);
 
-    // Spines, under everything else, in the same accent so an expanded thread
-    // is bounded by one colour from its root to its last reply.
-    for (const QRect &spine : card.spines)
-        painter->fillRect(spine, lineColour);
+    // Spines, under everything else, in the account's hue so an expanded thread
+    // is bounded by one colour from its root to its last reply. Muted against
+    // the pane's own background, unlike the accent bar: this line runs the full
+    // height of every reply and at full strength it shouts.
+    if (!card.spines.isEmpty()) {
+        const QColor base =
+            QGuiApplication::palette().color(QPalette::Base);
+        constexpr qreal kSpineWeight = 0.55;
+        const qreal inverse = 1.0 - kSpineWeight;
+        const QColor spineColour = QColor::fromRgbF(
+            lineColour.redF() * kSpineWeight + base.redF() * inverse,
+            lineColour.greenF() * kSpineWeight + base.greenF() * inverse,
+            lineColour.blueF() * kSpineWeight + base.blueF() * inverse);
+        for (const QRect &spine : card.spines)
+            painter->fillRect(spine, spineColour);
+    }
 
     // Selection outranks the model's foreground, and the order matters: a read
     // card carries a dimmed colour blended against the UNSELECTED background,
diff --git a/src/carddelegate.h b/src/carddelegate.h
index 317c78a..7012eaa 100644
--- a/src/carddelegate.h
+++ b/src/carddelegate.h
@@ -52,17 +52,21 @@ public:
     static QRect expanderRectFor(const QStyleOptionViewItem &option,
                                  const QModelIndex &index);
 
-    /// An account's colour as a thin LINE rather than as a chip's fill.
+    /// The colour the accent bar is painted in: the account's own, undiluted.
     ///
-    /// Never use the raw account colour for the accent bar or the spine. That
-    /// colour is chosen to be a background with legible text drawn on top
-    /// (TagColors::textColourOn picks black or white against it). The same
-    /// colour as a few pixels of line on the pane's own background is a
-    /// different problem: it has to be followable down a long expansion
-    /// WITHOUT competing with the senders beside it, which is the constraint
-    /// threadLineColour() states and meets by blending 0.35 toward the
-    /// palette's text. This blends the account colour toward the palette's
-    /// Base by the same weight, keeping the hue that identifies the account
-    /// and dropping the saturation that would shout.
+    /// Blending it toward the palette's Base was tried first, at the 0.35
+    /// weight threadLineColour() uses, and produced an INVISIBLE bar on a dark
+    /// theme: against a Base of (0.169, 0.169, 0.169) it landed at (0.18, 0.22,
+    /// 0.26), which is the background. The weight is a fraction OF THE ACCOUNT
+    /// COLOUR, so a low one keeps the background rather than the hue.
+    ///
+    /// An account colour is already chosen to be a chip's fill with legible
+    /// text on top, so it is muted to begin with; three pixels of a muted
+    /// colour is nothing. Nothing is drawn on this bar, so it needs none of the
+    /// contrast that choice was made for. The SPINE is where the muting belongs
+    /// and is blended in paint(): it runs the full height of every reply in an
+    /// expansion and has to be followable without competing with the senders.
+    ///
+    /// Falls back to threadLineColour() for a thread with no account tag.
     static QColor accentLineColour(const QColor &accountColour);
 };
diff --git a/src/cardlayout.cpp b/src/cardlayout.cpp
index 8d952b2..1a79e3b 100644
--- a/src/cardlayout.cpp
+++ b/src/cardlayout.cpp
@@ -87,7 +87,16 @@ CardLayout CardLayout::compute(const Input &input, const QRect &rect,
 
     // The date is measured first and the sender gets what is left, so a long
     // sender is elided rather than painting over the date.
-    const int dateWidth = metrics.horizontalAdvance(
+    //
+    // Measured BOLD whatever font this is handed. An unread card draws bold and
+    // the delegate computes its layout from the view's regular font, so a rect
+    // sized regular clips a bold date: 154px reserved against 170px needed, one
+    // digit of the year gone from every unread card. Reserving the wider of the
+    // two costs a few pixels on a read card and cannot disagree with what is
+    // painted.
+    QFont dateFont = font;
+    dateFont.setBold(true);
+    const int dateWidth = QFontMetrics(dateFont).horizontalAdvance(
         QStringLiteral("8888-88-88 88:88"));
     out.dateRect = QRect(right - dateWidth, lineOneTop, dateWidth,
                          metrics.height());
diff --git a/tests/test_cardlayout.cpp b/tests/test_cardlayout.cpp
index 1082f4c..c38f728 100644
--- a/tests/test_cardlayout.cpp
+++ b/tests/test_cardlayout.cpp
@@ -35,6 +35,7 @@ private slots:
     void dateIsFlushRight();
     void threadCardCarriesAnAccentBar();
     void replyCardCarriesNoAccentBar();
+    void theDateFitsWhenTheCardIsBold();
 };
 
 namespace {
@@ -231,5 +232,41 @@ void TestCardLayout::replyCardCarriesNoAccentBar()
     QCOMPARE(reply.spines.size(), 1);
 }
 
+void TestCardLayout::theDateFitsWhenTheCardIsBold()
+{
+    // An UNREAD card draws BOLD, and bold is wider. The layout is computed from
+    // option.font, which is the view's regular font, while the text is painted
+    // with the font initStyleOption resolved from the model's Qt::FontRole. So
+    // a date measured regular and drawn bold overflows its rect: measured at
+    // 154px reserved against 170px needed, which clipped the leading digit of
+    // the year off every unread card.
+    //
+    // The fix is in the layout rather than in the delegate: it reserves the
+    // BOLD width whatever font it is handed, so the two can never disagree.
+    QFont regular;
+    regular.setBold(false);
+    QFont bold = regular;
+    bold.setBold(true);
+
+    const QString sample = QStringLiteral("2025-08-10 06:26");
+    const int boldWidth = QFontMetrics(bold).horizontalAdvance(sample);
+
+    // Guard: bold must actually be wider here, or this asserts nothing.
+    QVERIFY2(boldWidth > QFontMetrics(regular).horizontalAdvance(sample),
+             "bold is not wider than regular in this environment, so this test "
+             "cannot detect the overflow it exists for");
+
+    const int h = CardLayout::heightFor(regular);
+    const CardLayout card =
+        CardLayout::compute(threadInput(), QRect(0, 0, 400, h), regular);
+
+    QVERIFY2(card.dateRect.width() >= boldWidth,
+             qPrintable(QStringLiteral("a layout computed from the REGULAR "
+                                       "font reserves %1px, and the date needs "
+                                       "%2px when the card draws bold")
+                            .arg(card.dateRect.width())
+                            .arg(boldWidth)));
+}
+
 QTEST_MAIN(TestCardLayout)
 #include "test_cardlayout.moc"