feat(ui): mark replies with a thread line, a tint and dimmer text

Indentation alone still read as a table, which was the user's original
complaint about the whole item. Three cues now say the rows belong to the
thread above them: a spine down the left of the expanded block with a stub out
to each reply, a background tint, and text a size down and undimmed only when
unread.

Both colours are mixed from the palette rather than fixed, the same rule
readColour follows: a tint that reads as grouping on a light theme is invisible
or muddy on a dark one. The tint is deliberately near the threshold of noticing,
since it sits beside the deleted and spam fills, which carry real meaning and
must stay the loudest thing in the list.

The spine is accumulated across the visible reply rows and drawn once after the
loop. Drawn per row it left a gap at every row boundary and read as a column of
dashes rather than as the structure holding the block together.

Two bugs fixed here, both mine, both from the previous commit:

Clicking the expander did nothing. setRootIsDecorated(false), needed to stop
the style painting its own indicator under ours, also removed the style's hit
area, so the glyph rendered perfectly and was inert. ThreadListView handles the
press itself now, over the strip the delegate reserves, leaving the rest of the
subject cell to select the row.

Every click then expanded rather than toggling, because isExpanded and
setExpanded are keyed on column 0 and were being asked about the subject-column
index, which always answers false.

Visible, clickable and toggling are three separate properties and a test for
one passes against the other two being broken: the pixel test proved the
triangle was drawn while it could not be clicked, and the first click test
proved it opened while it could never close. The test now clicks twice and
asserts open then closed.

replyRowsKeepTheirTextUnderTheThreadLine covers the other trap. paintEvent runs
AFTER the cells, so the first version of the tint filled the whole reply row and
erased the sender and subject the delegate had just drawn: zero surviving text
pixels, a block of blank tinted rows. The fill and the stub stay in the band
below the text, where the tag strip lives on thread rows.

1 files changed, 62 insertions, 2 deletions

diff --git a/src/threadlistmodel.cpp b/src/threadlistmodel.cpp
index 4828229..62b5195 100644
--- a/src/threadlistmodel.cpp
+++ b/src/threadlistmodel.cpp
@@ -75,6 +75,46 @@ QString ThreadListModel::flagGlyph()
     return glyph;
 }
 
+QColor ThreadListModel::replyBackground()
+{
+    // Mixed from the palette rather than fixed, for the same reason as
+    // readColour: a tint that reads as "grouped" on a light theme is either
+    // invisible or muddy on a dark one.
+    //
+    // Toward Text rather than toward a hue, so it darkens on a light theme and
+    // lightens on a dark one without picking a colour that means something
+    // else. 0.07 is deliberately near the threshold of noticing: it is a
+    // grouping cue sitting beside the deleted and spam fills, which carry
+    // actual meaning and must stay the loudest thing in the list.
+    const QPalette palette = QGuiApplication::palette();
+    const QColor base = palette.color(QPalette::Base);
+    const QColor text = palette.color(QPalette::Text);
+
+    constexpr qreal kWeight = 0.07;
+    const qreal inverse = 1.0 - kWeight;
+    return QColor::fromRgbF(
+        text.redF() * kWeight + base.redF() * inverse,
+        text.greenF() * kWeight + base.greenF() * inverse,
+        text.blueF() * kWeight + base.blueF() * inverse);
+}
+
+QColor ThreadListModel::threadLineColour()
+{
+    // Stronger than the tint, weaker than the text: the line is structure, so
+    // it has to be followable down a long expansion without competing with the
+    // senders beside it.
+    const QPalette palette = QGuiApplication::palette();
+    const QColor base = palette.color(QPalette::Base);
+    const QColor text = palette.color(QPalette::Text);
+
+    constexpr qreal kWeight = 0.35;
+    const qreal inverse = 1.0 - kWeight;
+    return QColor::fromRgbF(
+        text.redF() * kWeight + base.redF() * inverse,
+        text.greenF() * kWeight + base.greenF() * inverse,
+        text.blueF() * kWeight + base.blueF() * inverse);
+}
+
 QColor ThreadListModel::readColour()
 {
     // Derived from the palette, never hardcoded: a fixed grey that reads as
@@ -248,9 +288,29 @@ QVariant ThreadListModel::data(const QModelIndex &index, int role) const
             default:
                 return {};
             }
+        case Qt::BackgroundRole:
+            // Tinted, so an expanded thread reads as one block rather than as
+            // more table rows. Applied per cell here; ThreadListView fills the
+            // same colour across the strip's band so the row does not end up
+            // half tinted.
+            return replyBackground();
+        case Qt::FontRole: {
+            // A size down from the thread rows, so a thread reads as the
+            // heading and its replies as the contents. Never bold: an unread
+            // reply is still subordinate to the thread it belongs to, and the
+            // thread row above already carries the unread cue for the whole
+            // conversation.
+            QFont font = QGuiApplication::font();
+            if (font.pointSize() > 0)
+                font.setPointSize(qMax(6, font.pointSize() - 1));
+            else if (font.pixelSize() > 0)
+                font.setPixelSize(qMax(8, font.pixelSize() - 2));
+            return font;
+        }
         case Qt::ForegroundRole:
-            // Same rule as a thread row: read recedes, unread stays at the
-            // palette's own colour.
+            // Dimmed whether read or not, for the same reason as the font: a
+            // reply is subordinate content. An unread one is left undimmed so
+            // it can still be found.
             return node.isUnread() ? QVariant() : QVariant(readColour());
         default:
             return {};