File indexing completed on 2024-12-15 04:54:43

 /******************************************************************************
  *
  *  SPDX-FileCopyrightText: 2008 Szymon Tomasz Stefanek <pragma@kvirc.net>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  *
  *******************************************************************************/
 
 #include "core/view.h"
 #include "core/aggregation.h"
 #include "core/delegate.h"
 #include "core/groupheaderitem.h"
 #include "core/item.h"
 #include "core/messageitem.h"
 #include "core/model.h"
 #include "core/storagemodelbase.h"
 #include "core/theme.h"
 #include "core/widgetbase.h"
 #include "messagelistsettings.h"
 #include "messagelistutil.h"
 #include "messagelistutil_p.h"
 
 #include "MessageCore/StringUtil"
 
 #include <KMime/DateFormatter> // kdepimlibs
 
 #include <Akonadi/Item>
 #include <KTwoFingerTap>
 #include <QApplication>
 #include <QGestureEvent>
 #include <QHeaderView>
 #include <QHelpEvent>
 #include <QLineEdit>
 #include <QMenu>
 #include <QPainter>
 #include <QScrollBar>
 #include <QScroller>
 #include <QTimer>
 #include <QToolTip>
 
 #include "messagelist_debug.h"
 #include <KLocalizedString>
 
 using namespace MessageList::Core;
 
 class View::ViewPrivate
 {
 public:
     ViewPrivate(View *owner, Widget *parent)
         : q(owner)
         , mWidget(parent)
         , mDelegate(new Delegate(owner))
     {
     }
 
     void expandFullThread(const QModelIndex &index);
     void generalPaletteChanged();
     void onPressed(QMouseEvent *e);
     void gestureEvent(QGestureEvent *e);
     void tapTriggered(QTapGesture *tap);
     void tapAndHoldTriggered(QTapAndHoldGesture *tap);
     void twoFingerTapTriggered(KTwoFingerTap *tap);
 
     QColor mTextColor;
     View *const q;
 
     Widget *const mWidget;
     Model *mModel = nullptr;
     Delegate *const mDelegate;
 
     const Aggregation *mAggregation = nullptr; ///< The Aggregation we're using now, shallow pointer
     Theme *mTheme = nullptr; ///< The Theme we're using now, shallow pointer
     bool mNeedToApplyThemeColumns = false; ///< Flag signaling a pending application of theme columns
     Item *mLastCurrentItem = nullptr;
     QPoint mMousePressPosition;
     bool mSaveThemeColumnStateOnSectionResize = true; ///< This is used to filter out programmatic column resizes in slotSectionResized().
     QTimer *mSaveThemeColumnStateTimer = nullptr; ///< Used to trigger a delayed "save theme state"
     QTimer *mApplyThemeColumnsTimer = nullptr; ///< Used to trigger a delayed "apply theme columns"
     int mLastViewportWidth = -1;
     bool mIgnoreUpdateGeometries = false; ///< Shall we ignore the "update geometries" calls ?
     QScroller *mScroller = nullptr;
     bool mIsTouchEvent = false;
     bool mMousePressed = false;
     Qt::MouseEventSource mLastMouseSource = Qt::MouseEventNotSynthesized;
     bool mTapAndHoldActive = false;
     QRubberBand *mRubberBand = nullptr;
     Qt::GestureType mTwoFingerTap = Qt::CustomGesture;
 };
 
 View::View(Widget *pParent)
     : QTreeView(pParent)
     , d(new ViewPrivate(this, pParent))
 {
     d->mSaveThemeColumnStateTimer = new QTimer();
     connect(d->mSaveThemeColumnStateTimer, &QTimer::timeout, this, &View::saveThemeColumnState);
 
     d->mApplyThemeColumnsTimer = new QTimer();
     connect(d->mApplyThemeColumnsTimer, &QTimer::timeout, this, &View::applyThemeColumns);
 
     setItemDelegate(d->mDelegate);
     setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setAlternatingRowColors(true);
     setAllColumnsShowFocus(true);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
     viewport()->setAcceptDrops(true);
 
     d->mScroller = QScroller::scroller(viewport());
     QScrollerProperties scrollerProp;
     scrollerProp.setScrollMetric(QScrollerProperties::AcceleratingFlickMaximumTime, 0.2); // QTBUG-88249
     d->mScroller->setScrollerProperties(scrollerProp);
     d->mScroller->grabGesture(viewport());
 
     setAttribute(Qt::WA_AcceptTouchEvents);
     d->mTwoFingerTap = QGestureRecognizer::registerRecognizer(new KTwoFingerTapRecognizer());
     viewport()->grabGesture(d->mTwoFingerTap);
     viewport()->grabGesture(Qt::TapGesture);
     viewport()->grabGesture(Qt::TapAndHoldGesture);
 
     d->mRubberBand = new QRubberBand(QRubberBand::Rectangle, this);
 
     header()->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(header(), &QWidget::customContextMenuRequested, this, &View::slotHeaderContextMenuRequested);
     connect(header(), &QHeaderView::sectionResized, this, &View::slotHeaderSectionResized);
 
     header()->setSectionsClickable(true);
     header()->setSectionResizeMode(QHeaderView::Interactive);
     header()->setMinimumSectionSize(2); // QTreeView overrides our sections sizes if we set them smaller than this value
     header()->setDefaultSectionSize(2); // QTreeView overrides our sections sizes if we set them smaller than this value
 
     d->mModel = new Model(this);
     setModel(d->mModel);
 
     connect(d->mModel, &Model::statusMessage, pParent, &Widget::statusMessage);
 
     connect(selectionModel(), &QItemSelectionModel::selectionChanged, this, &View::slotSelectionChanged, Qt::UniqueConnection);
 
     // as in KDE3, when a root-item of a message thread is expanded, expand all children
     connect(this, &View::expanded, this, [this](const QModelIndex &index) {
         d->expandFullThread(index);
     });
 }
 
 View::~View()
 {
     if (d->mSaveThemeColumnStateTimer->isActive()) {
         d->mSaveThemeColumnStateTimer->stop();
     }
     delete d->mSaveThemeColumnStateTimer;
     if (d->mApplyThemeColumnsTimer->isActive()) {
         d->mApplyThemeColumnsTimer->stop();
     }
     delete d->mApplyThemeColumnsTimer;
 
     // Zero out the theme, aggregation and ApplyThemeColumnsTimer so Model will not cause accesses to them in its destruction process
     d->mApplyThemeColumnsTimer = nullptr;
 
     d->mTheme = nullptr;
     d->mAggregation = nullptr;
 }
 
 Model *View::model() const
 {
     return d->mModel;
 }
 
 Delegate *View::delegate() const
 {
     return d->mDelegate;
 }
 
 void View::ignoreCurrentChanges(bool ignore)
 {
     if (ignore) {
         disconnect(selectionModel(), &QItemSelectionModel::selectionChanged, this, &View::slotSelectionChanged);
         viewport()->setUpdatesEnabled(false);
     } else {
         connect(selectionModel(), &QItemSelectionModel::selectionChanged, this, &View::slotSelectionChanged, Qt::UniqueConnection);
         viewport()->setUpdatesEnabled(true);
     }
 }
 
 void View::ignoreUpdateGeometries(bool ignore)
 {
     d->mIgnoreUpdateGeometries = ignore;
 }
 
 bool View::isScrollingLocked() const
 {
     // There is another popular requisite: people want the view to automatically
     // scroll in order to show new arriving mail. This actually makes sense
     // only when the view is sorted by date and the new mail is (usually) either
     // appended at the bottom or inserted at the top. It would be also confusing
     // when the user is browsing some other thread in the meantime.
     //
     // So here we make a simple guess: if the view is scrolled somewhere in the
     // middle then we assume that the user is browsing other threads and we
     // try to keep the currently selected item steady on the screen.
     // When the view is "locked" to the top (scrollbar value 0) or to the
     // bottom (scrollbar value == maximum) then we assume that the user
     // isn't browsing and we should attempt to show the incoming messages
     // by keeping the view "locked".
     //
     // The "locking" also doesn't make sense in the first big fill view job.
     // [Well this concept is pre-akonadi. Now the loading is all async anyway...
     //  So all this code is actually triggered during the initial loading, too.]
     const int scrollBarPosition = verticalScrollBar()->value();
     const int scrollBarMaximum = verticalScrollBar()->maximum();
     const SortOrder *sortOrder = d->mModel->sortOrder();
     const bool lockView = (
                               // not the first loading job
                               !d->mModel->isLoading())
         && (
                               // messages sorted by date
                               (sortOrder->messageSorting() == SortOrder::SortMessagesByDateTime)
                               || (sortOrder->messageSorting() == SortOrder::SortMessagesByDateTimeOfMostRecent))
         && (
                               // scrollbar at top (Descending order) or bottom (Ascending order)
                               (scrollBarPosition == 0 && sortOrder->messageSortDirection() == SortOrder::Descending)
                               || (scrollBarPosition == scrollBarMaximum && sortOrder->messageSortDirection() == SortOrder::Ascending));
     return lockView;
 }
 
 void View::updateGeometries()
 {
     if (d->mIgnoreUpdateGeometries || !d->mModel) {
         return;
     }
 
     const int scrollBarPositionBefore = verticalScrollBar()->value();
     const bool lockView = isScrollingLocked();
 
     QTreeView::updateGeometries();
 
     if (lockView) {
         // we prefer to keep the view locked to the top or bottom
         if (scrollBarPositionBefore != 0) {
             // we wanted the view to be locked to the bottom
             if (verticalScrollBar()->value() != verticalScrollBar()->maximum()) {
                 verticalScrollBar()->setValue(verticalScrollBar()->maximum());
             }
         } // else we wanted the view to be locked to top and we shouldn't need to do anything
     }
 }
 
 StorageModel *View::storageModel() const
 {
     return d->mModel->storageModel();
 }
 
 void View::setAggregation(const Aggregation *aggregation)
 {
     d->mAggregation = aggregation;
     d->mModel->setAggregation(aggregation);
 
     // use uniform row heights to speed up, but only if there are no group headers used
     setUniformRowHeights(d->mAggregation->grouping() == Aggregation::NoGrouping);
 }
 
 void View::setTheme(Theme *theme)
 {
     d->mNeedToApplyThemeColumns = true;
     d->mTheme = theme;
     d->mDelegate->setTheme(theme);
     d->mModel->setTheme(theme);
 }
 
 void View::setSortOrder(const SortOrder *sortOrder)
 {
     d->mModel->setSortOrder(sortOrder);
 }
 
 void View::reload()
 {
     setStorageModel(storageModel());
 }
 
 void View::setStorageModel(StorageModel *storageModel, PreSelectionMode preSelectionMode)
 {
     // This will cause the model to be reset.
     d->mSaveThemeColumnStateOnSectionResize = false;
     d->mModel->setStorageModel(storageModel, preSelectionMode);
     d->mSaveThemeColumnStateOnSectionResize = true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 // Theme column state machinery
 //
 // This is yet another beast to beat. The QHeaderView behaviour, at the time of writing,
 // is quite unpredictable. This is due to the complex interaction with the model, with the QTreeView
 // and due to its attempts to delay the layout jobs. The delayed layouts, especially, may
 // cause the widths of the columns to quickly change in an unexpected manner in a place
 // where previously they have been always settled to the values you set...
 //
 // So here we have the tools to:
 //
 // - Apply the saved state of the theme columns (applyThemeColumns()).
 //   This function computes the "best fit" state of the visible columns and tries
 //   to apply it to QHeaderView. It also saves the new computed state to the Theme object.
 //
 // - Explicitly save the column state, used when the user changes the widths or visibility manually.
 //   This is called through a delayed timer after a column has been resized or used directly
 //   when the visibility state of a column has been changed by toggling a popup menu entry.
 //
 // - Display the column state context popup menu and handle its actions
 //
 // - Apply the theme columns when the theme changes, when the model changes or when
 //   the widget is resized.
 //
 // - Avoid saving a corrupted column state in that QHeaderView can be found *very* frequently.
 //
 
 void View::applyThemeColumns()
 {
     if (!d->mApplyThemeColumnsTimer) {
         return;
     }
 
     if (d->mApplyThemeColumnsTimer->isActive()) {
         d->mApplyThemeColumnsTimer->stop();
     }
 
     if (!d->mTheme) {
         return;
     }
 
     // qCDebug(MESSAGELIST_LOG) << "Apply theme columns";
 
     const QList<Theme::Column *> &columns = d->mTheme->columns();
 
     if (columns.isEmpty()) {
         return; // bad theme
     }
 
     if (!viewport()->isVisible()) {
         return; // invisible
     }
 
     if (viewport()->width() < 1) {
         return; // insane width
     }
     const int viewportWidth = viewport()->width();
     d->mLastViewportWidth = viewportWidth;
 
     // Now we want to distribute the available width on all the visible columns.
     //
     // The rules:
     // - The visible columns will span the width of the view, if possible.
     // - The columns with a saved width should take that width.
     // - The columns on the left should take more space, if possible.
     // - The columns with no text take just slightly more than their size hint.
     //   while the columns with text take possibly a lot more.
     //
 
     // Note that the first column is always shown (it can't be hidden at all)
 
     // The algorithm below is a sort of compromise between:
     // - Saving the user preferences for widths
     // - Using exactly the available view space
     //
     // It "tends to work" in all cases:
     // - When there are no user preferences saved and the column widths must be
     //   automatically computed to make best use of available space
     // - When there are user preferences for only some of the columns
     //   and that should be somewhat preserved while still using all the
     //   available space.
     // - When all the columns have well defined saved widths
 
     int idx = 0;
 
     // Gather total size "hint" for visible sections: if the widths of the columns wers
     // all saved then the total hint is equal to the total saved width.
 
     int totalVisibleWidthHint = 0;
     QList<int> lColumnSizeHints;
     for (const auto col : std::as_const(columns)) {
         if (col->currentlyVisible() || (idx == 0)) {
             // qCDebug(MESSAGELIST_LOG) << "Column " << idx << " will be visible";
             // Column visible
             const int savedWidth = col->currentWidth();
             const int hintWidth = d->mDelegate->sizeHintForItemTypeAndColumn(Item::Message, idx).width();
             totalVisibleWidthHint += savedWidth > 0 ? savedWidth : hintWidth;
             lColumnSizeHints.append(hintWidth);
             // qCDebug(MESSAGELIST_LOG) << "Column " << idx << " size hint is " << hintWidth;
         } else {
             // qCDebug(MESSAGELIST_LOG) << "Column " << idx << " will be not visible";
             // The column is not visible
             lColumnSizeHints.append(-1); // dummy
         }
         idx++;
     }
 
     if (totalVisibleWidthHint < 16) {
         totalVisibleWidthHint = 16; // be reasonable
     }
 
     // Now compute somewhat "proportional" widths.
     idx = 0;
 
     QList<double> lColumnWidths;
     lColumnWidths.reserve(columns.count());
     int totalVisibleWidth = 0;
     for (const auto col : std::as_const(columns)) {
         double savedWidth = col->currentWidth();
         double hintWidth = savedWidth > 0 ? savedWidth : lColumnSizeHints.at(idx);
         double realWidth;
 
         if (col->currentlyVisible() || (idx == 0)) {
             if (col->containsTextItems()) {
                 // the column contains text items, it should get more space (if possible)
                 realWidth = ((hintWidth * viewportWidth) / totalVisibleWidthHint);
             } else {
                 // the column contains no text items, it should get exactly its hint/saved width.
                 realWidth = hintWidth;
             }
 
             if (realWidth < 2) {
                 realWidth = 2; // don't allow very insane values
             }
 
             totalVisibleWidth += realWidth;
         } else {
             // Column not visible
             realWidth = -1;
         }
 
         lColumnWidths.append(realWidth);
 
         idx++;
     }
 
     // Now the algorithm above may be wrong for several reasons...
     // - We're using fixed widths for certain columns and proportional
     //   for others...
     // - The user might have changed the width of the view from the
     //   time in that the widths have been saved
     // - There are some (not well identified) issues with the QTreeView
     //   scrollbar that make our view appear larger or shorter by 2-3 pixels
     //   sometimes.
     // - ...
     // So we correct the previous estimates by trying to use exactly
     // the available space.
 
     idx = 0;
 
     if (totalVisibleWidth != viewportWidth) {
         // The estimated widths were not using exactly the available space.
         if (totalVisibleWidth < viewportWidth) {
             // We were using less space than available.
 
             // Give the additional space to the text columns
             // also give more space to the first ones and less space to the last ones
             qreal available = viewportWidth - totalVisibleWidth;
 
             for (int idx = 0; idx < columns.count(); ++idx) {
                 Theme::Column *column = columns.at(idx);
                 if ((column->currentlyVisible() || (idx == 0)) && column->containsTextItems()) {
                     // give more space to this column
                     available /= 2; // eat half of the available space
                     lColumnWidths[idx] += available; // and give it to this column
                     if (available < 1) {
                         break; // no more space to give away
                     }
                 }
             }
 
             // if any space is still available, give it to the first column
             if (available >= 1) {
                 lColumnWidths[0] += available;
             }
         } else {
             // We were using more space than available
 
             // If the columns span more than the view then
             // try to squeeze them in order to make them fit
             double missing = totalVisibleWidth - viewportWidth;
             if (missing > 0) {
                 const int count = lColumnWidths.count();
                 idx = count - 1;
 
                 while (idx >= 0) {
                     if (columns.at(idx)->currentlyVisible() || (idx == 0)) {
                         double chop = lColumnWidths.at(idx) - lColumnSizeHints.at(idx);
                         if (chop > 0) {
                             if (chop > missing) {
                                 chop = missing;
                             }
                             lColumnWidths[idx] -= chop;
                             missing -= chop;
                             if (missing < 1) {
                                 break; // no more space to recover
                             }
                         }
                     } // else it's invisible
                     idx--;
                 }
             }
         }
     }
 
     // We're ready to assign widths.
 
     bool oldSave = d->mSaveThemeColumnStateOnSectionResize;
     d->mSaveThemeColumnStateOnSectionResize = false;
 
     // A huge problem here is that QHeaderView goes quite nuts if we show or hide sections
     // while resizing them. This is because it has several machineries aimed to delay
     // the layout to the last possible moment. So if we show a column, it will tend to
     // screw up the layout of other ones.
 
     // We first loop showing/hiding columns then.
 
     idx = 0;
 
     for (const auto col : std::as_const(columns)) {
         bool visible = (idx == 0) || col->currentlyVisible();
         // qCDebug(MESSAGELIST_LOG) << "Column " << idx << " visible " << visible;
         col->setCurrentlyVisible(visible);
         header()->setSectionHidden(idx, !visible);
         idx++;
     }
 
     // Then we loop assigning widths. This is still complicated since QHeaderView tries
     // very badly to stretch the last section and thus will resize it in the meantime.
     // But seems to work most of the times...
 
     idx = 0;
 
     for (const auto col : std::as_const(columns)) {
         if (col->currentlyVisible()) {
             const double columnWidth(lColumnWidths.at(idx));
             col->setCurrentWidth(columnWidth);
             // Laurent Bug 358855 - message list column widths lost when program closed
             // I need to investigate if this code is still necessary (all method)
             header()->resizeSection(idx, static_cast<int>(columnWidth));
         } else {
             col->setCurrentWidth(-1);
         }
         idx++;
     }
 
     idx = 0;
 
     bool bTriggeredQtBug = false;
     for (const auto col : std::as_const(columns)) {
         if (!header()->isSectionHidden(idx)) {
             if (!col->currentlyVisible()) {
                 bTriggeredQtBug = true;
             }
         }
         idx++;
     }
 
     setHeaderHidden(d->mTheme->viewHeaderPolicy() == Theme::NeverShowHeader);
 
     d->mSaveThemeColumnStateOnSectionResize = oldSave;
     d->mNeedToApplyThemeColumns = false;
 
     static bool bAllowRecursion = true;
 
     if (bTriggeredQtBug && bAllowRecursion) {
         bAllowRecursion = false;
         // qCDebug(MESSAGELIST_LOG) << "I've triggered the QHeaderView bug: trying to fix by calling myself again";
         applyThemeColumns();
         bAllowRecursion = true;
     }
 }
 
 void View::triggerDelayedApplyThemeColumns()
 {
     if (d->mApplyThemeColumnsTimer->isActive()) {
         d->mApplyThemeColumnsTimer->stop();
     }
     d->mApplyThemeColumnsTimer->setSingleShot(true);
     d->mApplyThemeColumnsTimer->start(100);
 }
 
 void View::saveThemeColumnState()
 {
     if (d->mSaveThemeColumnStateTimer->isActive()) {
         d->mSaveThemeColumnStateTimer->stop();
     }
 
     if (!d->mTheme) {
         return;
     }
 
     if (d->mNeedToApplyThemeColumns) {
         return; // don't save the state if it hasn't been applied at all
     }
 
     // qCDebug(MESSAGELIST_LOG) << "Save theme column state";
 
     const auto columns = d->mTheme->columns();
 
     if (columns.isEmpty()) {
         return; // bad theme
     }
 
     int idx = 0;
 
     for (const auto col : std::as_const(columns)) {
         if (header()->isSectionHidden(idx)) {
             // qCDebug(MESSAGELIST_LOG) << "Section " << idx << " is hidden";
             col->setCurrentlyVisible(false);
             col->setCurrentWidth(-1); // reset (hmmm... we could use the "don't touch" policy here too...)
         } else {
             // qCDebug(MESSAGELIST_LOG) << "Section " << idx << " is visible and has size " << header()->sectionSize( idx );
             col->setCurrentlyVisible(true);
             col->setCurrentWidth(header()->sectionSize(idx));
         }
         idx++;
     }
 }
 
 void View::triggerDelayedSaveThemeColumnState()
 {
     if (d->mSaveThemeColumnStateTimer->isActive()) {
         d->mSaveThemeColumnStateTimer->stop();
     }
     d->mSaveThemeColumnStateTimer->setSingleShot(true);
     d->mSaveThemeColumnStateTimer->start(200);
 }
 
 void View::resizeEvent(QResizeEvent *e)
 {
     qCDebug(MESSAGELIST_LOG) << "Resize event enter (viewport width is " << viewport()->width() << ")";
 
     QTreeView::resizeEvent(e);
 
     if (!isVisible()) {
         return; // don't play with
     }
 
     if (d->mLastViewportWidth != viewport()->width()) {
         triggerDelayedApplyThemeColumns();
     }
 
     if (header()->isVisible()) {
         return;
     }
 
     // header invisible
 
     bool oldSave = d->mSaveThemeColumnStateOnSectionResize;
     d->mSaveThemeColumnStateOnSectionResize = false;
 
     const int count = header()->count();
     if ((count - header()->hiddenSectionCount()) < 2) {
         // a single column visible: resize it
         int visibleIndex;
         for (visibleIndex = 0; visibleIndex < count; visibleIndex++) {
             if (!header()->isSectionHidden(visibleIndex)) {
                 break;
             }
         }
         if (visibleIndex < count) {
             header()->resizeSection(visibleIndex, viewport()->width() - 4);
         }
     }
 
     d->mSaveThemeColumnStateOnSectionResize = oldSave;
 
     triggerDelayedSaveThemeColumnState();
 }
 
 void View::paintEvent(QPaintEvent *event)
 {
 #if 0
     if (/*mFirstResult &&*/ (!model() || model()->rowCount() == 0)) {
         QPainter p(viewport());
 
         QFont font = p.font();
         font.setItalic(true);
         p.setFont(font);
 
         if (!d->mTextColor.isValid()) {
             d->generalPaletteChanged();
         }
         p.setPen(d->mTextColor);
 
         p.drawText(QRect(0, 0, width(), height()), Qt::AlignCenter, i18n("No result found"));
     } else {
         QTreeView::paintEvent(event);
     }
 #else
     QTreeView::paintEvent(event);
 #endif
 }
 
 void View::modelAboutToEmitLayoutChanged()
 {
     // QHeaderView goes totally NUTS with a layoutChanged() call
     d->mSaveThemeColumnStateOnSectionResize = false;
 }
 
 void View::modelEmittedLayoutChanged()
 {
     // This is after a first chunk of work has been done by the model: do apply column states
     d->mSaveThemeColumnStateOnSectionResize = true;
     applyThemeColumns();
 }
 
 void View::slotHeaderSectionResized(int logicalIndex, int oldWidth, int newWidth)
 {
     Q_UNUSED(logicalIndex)
     Q_UNUSED(oldWidth)
     Q_UNUSED(newWidth)
 
     if (d->mSaveThemeColumnStateOnSectionResize) {
         triggerDelayedSaveThemeColumnState();
     }
 }
 
 int View::sizeHintForColumn(int logicalColumnIndex) const
 {
     // QTreeView: please don't touch my column widths...
     int w = header()->sectionSize(logicalColumnIndex);
     if (w > 0) {
         return w;
     }
     if (!d->mDelegate) {
         return 32; // dummy
     }
     w = d->mDelegate->sizeHintForItemTypeAndColumn(Item::Message, logicalColumnIndex).width();
     return w;
 }
 
 void View::slotHeaderContextMenuRequested(const QPoint &pnt)
 {
     if (!d->mTheme) {
         return;
     }
 
     const auto columns = d->mTheme->columns();
 
     if (columns.isEmpty()) {
         return; // bad theme
     }
 
     // the menu for the columns
     QMenu menu;
 
     int idx = 0;
     for (const auto col : std::as_const(columns)) {
         QAction *act = menu.addAction(col->label());
         act->setCheckable(true);
         act->setChecked(!header()->isSectionHidden(idx));
         if (idx == 0) {
             act->setEnabled(false);
         }
         QObject::connect(act, &QAction::triggered, this, [this, idx] {
             slotShowHideColumn(idx);
         });
 
         idx++;
     }
 
     menu.addSeparator();
     {
         QAction *act = menu.addAction(i18n("Adjust Column Sizes"));
         QObject::connect(act, &QAction::triggered, this, &View::slotAdjustColumnSizes);
     }
     {
         QAction *act = menu.addAction(i18n("Show Default Columns"));
         QObject::connect(act, &QAction::triggered, this, &View::slotShowDefaultColumns);
     }
     menu.addSeparator();
     {
         QAction *act = menu.addAction(i18n("Display Tooltips"));
         act->setCheckable(true);
         act->setChecked(MessageListSettings::self()->messageToolTipEnabled());
         QObject::connect(act, &QAction::triggered, this, &View::slotDisplayTooltips);
     }
     menu.addSeparator();
 
     MessageList::Util::fillViewMenu(&menu, d->mWidget);
 
     menu.exec(header()->mapToGlobal(pnt));
 }
 
 void View::slotAdjustColumnSizes()
 {
     if (!d->mTheme) {
         return;
     }
 
     d->mTheme->resetColumnSizes();
     applyThemeColumns();
 }
 
 void View::slotShowDefaultColumns()
 {
     if (!d->mTheme) {
         return;
     }
 
     d->mTheme->resetColumnState();
     applyThemeColumns();
 }
 
 void View::slotDisplayTooltips(bool showTooltips)
 {
     MessageListSettings::self()->setMessageToolTipEnabled(showTooltips);
 }
 
 void View::slotShowHideColumn(int columnIdx)
 {
     if (!d->mTheme) {
         return; // oops
     }
 
     if (columnIdx == 0) {
         return; // can never be hidden
     }
 
     if (columnIdx >= d->mTheme->columns().count()) {
         return;
     }
 
     const bool showIt = header()->isSectionHidden(columnIdx);
 
     Theme::Column *column = d->mTheme->columns().at(columnIdx);
     Q_ASSERT(column);
 
     // first save column state (as it is, with the column still in previous state)
     saveThemeColumnState();
 
     // If a section has just been shown, invalidate its width in the skin
     // since QTreeView assigned it a (possibly insane) default width.
     // If a section has been hidden, then invalidate its width anyway...
     // so finally invalidate width always, here.
     column->setCurrentlyVisible(showIt);
     column->setCurrentWidth(-1);
 
     // then apply theme columns to re-compute proportional widths (so we hopefully stay in the view)
     applyThemeColumns();
 }
 
 Item *View::currentItem() const
 {
     QModelIndex idx = currentIndex();
     if (!idx.isValid()) {
         return nullptr;
     }
     Item *it = static_cast<Item *>(idx.internalPointer());
     Q_ASSERT(it);
     return it;
 }
 
 MessageItem *View::currentMessageItem(bool selectIfNeeded) const
 {
     Item *it = currentItem();
     if (!it || (it->type() != Item::Message)) {
         return nullptr;
     }
 
     if (selectIfNeeded) {
         // Keep things coherent, if the user didn't select it, but acted on it via
         // a shortcut, do select it now.
         if (!selectionModel()->isSelected(currentIndex())) {
             selectionModel()->select(currentIndex(), QItemSelectionModel::Select | QItemSelectionModel::Current | QItemSelectionModel::Rows);
         }
     }
 
     return static_cast<MessageItem *>(it);
 }
 
 void View::setCurrentMessageItem(MessageItem *it, bool center)
 {
     if (it) {
         qCDebug(MESSAGELIST_LOG) << "Setting current message to" << it->subject();
 
         const QModelIndex index = d->mModel->index(it, 0);
         selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select | QItemSelectionModel::Current | QItemSelectionModel::Rows);
         if (center) {
             scrollTo(index, QAbstractItemView::PositionAtCenter);
         }
     } else {
         selectionModel()->setCurrentIndex(QModelIndex(), QItemSelectionModel::Current | QItemSelectionModel::Clear);
     }
 }
 
 bool View::selectionEmpty() const
 {
     return selectionModel()->selectedRows().isEmpty();
 }
 
 QList<MessageItem *> View::selectionAsMessageItemList(bool includeCollapsedChildren) const
 {
     QList<MessageItem *> selectedMessages;
 
     QModelIndexList lSelected = selectionModel()->selectedRows();
     if (lSelected.isEmpty()) {
         return selectedMessages;
     }
     for (const auto &idx : std::as_const(lSelected)) {
         // The asserts below are theoretically valid but at the time
         // of writing they fail because of a bug in QItemSelectionModel::selectedRows()
         // which returns also non-selectable items.
 
         // Q_ASSERT( selectedItem->type() == Item::Message );
         // Q_ASSERT( ( *it ).isValid() );
 
         if (!idx.isValid()) {
             continue;
         }
 
         Item *selectedItem = static_cast<Item *>(idx.internalPointer());
         Q_ASSERT(selectedItem);
 
         if (selectedItem->type() != Item::Message) {
             continue;
         }
 
         if (!static_cast<MessageItem *>(selectedItem)->isValid()) {
             continue;
         }
 
         Q_ASSERT(!selectedMessages.contains(static_cast<MessageItem *>(selectedItem)));
 
         if (includeCollapsedChildren && (selectedItem->childItemCount() > 0) && (!isExpanded(idx))) {
             static_cast<MessageItem *>(selectedItem)->subTreeToList(selectedMessages);
         } else {
             selectedMessages.append(static_cast<MessageItem *>(selectedItem));
         }
     }
 
     return selectedMessages;
 }
 
 QList<MessageItem *> View::currentThreadAsMessageItemList() const
 {
     QList<MessageItem *> currentThread;
 
     MessageItem *msg = currentMessageItem();
     if (!msg) {
         return currentThread;
     }
 
     while (msg->parent()) {
         if (msg->parent()->type() != Item::Message) {
             break;
         }
         msg = static_cast<MessageItem *>(msg->parent());
     }
 
     msg->subTreeToList(currentThread);
 
     return currentThread;
 }
 
 void View::setChildrenExpanded(const Item *root, bool expand)
 {
     Q_ASSERT(root);
     auto childList = root->childItems();
     if (!childList) {
         return;
     }
     for (const auto child : std::as_const(*childList)) {
         QModelIndex idx = d->mModel->index(child, 0);
         Q_ASSERT(idx.isValid());
         Q_ASSERT(static_cast<Item *>(idx.internalPointer()) == child);
 
         if (expand) {
             setExpanded(idx, true);
 
             if (child->childItemCount() > 0) {
                 setChildrenExpanded(child, true);
             }
         } else {
             if (child->childItemCount() > 0) {
                 setChildrenExpanded(child, false);
             }
 
             setExpanded(idx, false);
         }
     }
 }
 
 void View::ViewPrivate::generalPaletteChanged()
 {
     const QPalette palette = q->viewport()->palette();
     QColor color = palette.text().color();
     color.setAlpha(128);
     mTextColor = color;
 }
 
 void View::ViewPrivate::expandFullThread(const QModelIndex &index)
 {
     if (!index.isValid()) {
         return;
     }
 
     Item *item = static_cast<Item *>(index.internalPointer());
     if (item->type() != Item::Message) {
         return;
     }
 
     if (!static_cast<MessageItem *>(item)->parent() || (static_cast<MessageItem *>(item)->parent()->type() != Item::Message)) {
         q->setChildrenExpanded(item, true);
     }
 }
 
 void View::setCurrentThreadExpanded(bool expand)
 {
     Item *it = currentItem();
     if (!it) {
         return;
     }
 
     if (it->type() == Item::GroupHeader) {
         setExpanded(currentIndex(), expand);
     } else if (it->type() == Item::Message) {
         auto message = static_cast<MessageItem *>(it);
         while (message->parent()) {
             if (message->parent()->type() != Item::Message) {
                 break;
             }
             message = static_cast<MessageItem *>(message->parent());
         }
 
         if (expand) {
             setExpanded(d->mModel->index(message, 0), true);
             setChildrenExpanded(message, true);
         } else {
             setChildrenExpanded(message, false);
             setExpanded(d->mModel->index(message, 0), false);
         }
     }
 }
 
 void View::setAllThreadsExpanded(bool expand)
 {
     scheduleDelayedItemsLayout();
     if (d->mAggregation->grouping() == Aggregation::NoGrouping) {
         // we have no groups so threads start under the root item: just expand/unexpand all
         setChildrenExpanded(d->mModel->rootItem(), expand);
         return;
     }
 
     // grouping is in effect: must expand/unexpand one level lower
 
     auto childList = d->mModel->rootItem()->childItems();
     if (!childList) {
         return;
     }
 
     for (const auto item : std::as_const(*childList)) {
         setChildrenExpanded(item, expand);
     }
 }
 
 void View::setAllGroupsExpanded(bool expand)
 {
     if (d->mAggregation->grouping() == Aggregation::NoGrouping) {
         return; // no grouping in effect
     }
 
     Item *item = d->mModel->rootItem();
 
     auto childList = item->childItems();
     if (!childList) {
         return;
     }
 
     scheduleDelayedItemsLayout();
     for (const auto item : std::as_const(*childList)) {
         Q_ASSERT(item->type() == Item::GroupHeader);
         QModelIndex idx = d->mModel->index(item, 0);
         Q_ASSERT(idx.isValid());
         Q_ASSERT(static_cast<Item *>(idx.internalPointer()) == item);
         if (expand) {
             if (!isExpanded(idx)) {
                 setExpanded(idx, true);
             }
         } else {
             if (isExpanded(idx)) {
                 setExpanded(idx, false);
             }
         }
     }
 }
 
 void View::selectMessageItems(const QList<MessageItem *> &list)
 {
     QItemSelection selection;
     for (const auto mi : list) {
         Q_ASSERT(mi);
         QModelIndex idx = d->mModel->index(mi, 0);
         Q_ASSERT(idx.isValid());
         Q_ASSERT(static_cast<MessageItem *>(idx.internalPointer()) == mi);
         if (!selectionModel()->isSelected(idx)) {
             selection.append(QItemSelectionRange(idx));
         }
         ensureDisplayedWithParentsExpanded(mi);
     }
     if (!selection.isEmpty()) {
         selectionModel()->select(selection, QItemSelectionModel::Select | QItemSelectionModel::Rows);
     }
 }
 
 static inline bool message_type_matches(Item *item, MessageTypeFilter messageTypeFilter)
 {
     switch (messageTypeFilter) {
     case MessageTypeAny:
         return true;
         break;
     case MessageTypeUnreadOnly:
         return !item->status().isRead();
         break;
     default:
         // nothing here
         break;
     }
 
     // never reached
     Q_ASSERT(false);
     return false;
 }
 
 Item *View::messageItemAfter(Item *referenceItem, MessageTypeFilter messageTypeFilter, bool loop)
 {
     if (!storageModel()) {
         return nullptr; // no folder
     }
 
     // find the item to start with
     Item *below;
 
     if (referenceItem) {
         // there was a current item: we start just below it
         if ((referenceItem->childItemCount() > 0) && ((messageTypeFilter != MessageTypeAny) || isExpanded(d->mModel->index(referenceItem, 0)))) {
             // the current item had children: either expanded or we want unread/new messages (and so we'll expand it if it isn't)
             below = referenceItem->itemBelow();
         } else {
             // the current item had no children: ask the parent to find the item below
             Q_ASSERT(referenceItem->parent());
             below = referenceItem->parent()->itemBelowChild(referenceItem);
         }
 
         if (!below) {
             // reached the end
             if (loop) {
                 // try re-starting from top
                 below = d->mModel->rootItem()->itemBelow();
                 Q_ASSERT(below); // must exist (we had a current item)
 
                 if (below == referenceItem) {
                     return nullptr; // only one item in folder: loop complete
                 }
             } else {
                 // looping not requested
                 return nullptr;
             }
         }
     } else {
         // there was no current item, start from beginning
         below = d->mModel->rootItem()->itemBelow();
 
         if (!below) {
             return nullptr; // folder empty
         }
     }
 
     // ok.. now below points to the next message.
     // While it doesn't satisfy our requirements, go further down
 
     QModelIndex parentIndex = d->mModel->index(below->parent(), 0);
     QModelIndex belowIndex = d->mModel->index(below, 0);
 
     Q_ASSERT(belowIndex.isValid());
 
     while (
         // is not a message (we want messages, don't we ?)
         (below->type() != Item::Message) || // message filter doesn't match
         (!message_type_matches(below, messageTypeFilter)) || // is hidden (and we don't want hidden items as they aren't "officially" in the view)
         isRowHidden(belowIndex.row(), parentIndex) || // is not enabled or not selectable
         ((d->mModel->flags(belowIndex) & (Qt::ItemIsSelectable | Qt::ItemIsEnabled)) != (Qt::ItemIsSelectable | Qt::ItemIsEnabled))) {
         // find the next one
         if ((below->childItemCount() > 0) && ((messageTypeFilter != MessageTypeAny) || isExpanded(belowIndex))) {
             // the current item had children: either expanded or we want unread messages (and so we'll expand it if it isn't)
             below = below->itemBelow();
         } else {
             // the current item had no children: ask the parent to find the item below
             Q_ASSERT(below->parent());
             below = below->parent()->itemBelowChild(below);
         }
 
         if (!below) {
             // we reached the end of the folder
             if (loop) {
                 // looping requested
                 if (referenceItem) { // <-- this means "we have started from something that is not the top: looping makes sense"
                     below = d->mModel->rootItem()->itemBelow();
                 }
                 // else mi == 0 and below == 0: we have started from the beginning and reached the end (it will fail the test below and exit)
             } else {
                 // looping not requested: nothing more to do
                 return nullptr;
             }
         }
 
         if (below == referenceItem) {
             Q_ASSERT(loop);
             return nullptr; // looped and returned back to the first message
         }
 
         parentIndex = d->mModel->index(below->parent(), 0);
         belowIndex = d->mModel->index(below, 0);
 
         Q_ASSERT(belowIndex.isValid());
     }
 
     return below;
 }
 
 Item *View::firstMessageItem(MessageTypeFilter messageTypeFilter)
 {
     return messageItemAfter(nullptr, messageTypeFilter, false);
 }
 
 Item *View::nextMessageItem(MessageTypeFilter messageTypeFilter, bool loop)
 {
     return messageItemAfter(currentMessageItem(false), messageTypeFilter, loop);
 }
 
 Item *View::deepestExpandedChild(Item *referenceItem) const
 {
     const int children = referenceItem->childItemCount();
     if (children > 0 && isExpanded(d->mModel->index(referenceItem, 0))) {
         return deepestExpandedChild(referenceItem->childItem(children - 1));
     } else {
         return referenceItem;
     }
 }
 
 Item *View::messageItemBefore(Item *referenceItem, MessageTypeFilter messageTypeFilter, bool loop)
 {
     if (!storageModel()) {
         return nullptr; // no folder
     }
 
     // find the item to start with
     Item *above;
 
     if (referenceItem) {
         Item *parent = referenceItem->parent();
         Item *siblingAbove = parent ? parent->itemAboveChild(referenceItem) : nullptr;
         // there was a current item: we start just above it
         if ((siblingAbove && siblingAbove != referenceItem && siblingAbove != parent) && (siblingAbove->childItemCount() > 0)
             && ((messageTypeFilter != MessageTypeAny) || (isExpanded(d->mModel->index(siblingAbove, 0))))) {
             // the current item had children: either expanded or we want unread/new messages (and so we'll expand it if it isn't)
             above = deepestExpandedChild(siblingAbove);
         } else {
             // the current item had no children: ask the parent to find the item above
             Q_ASSERT(referenceItem->parent());
             above = referenceItem->parent()->itemAboveChild(referenceItem);
         }
 
         if ((!above) || (above == d->mModel->rootItem())) {
             // reached the beginning
             if (loop) {
                 // try re-starting from bottom
                 above = d->mModel->rootItem()->deepestItem();
                 Q_ASSERT(above); // must exist (we had a current item)
                 Q_ASSERT(above != d->mModel->rootItem());
 
                 if (above == referenceItem) {
                     return nullptr; // only one item in folder: loop complete
                 }
             } else {
                 // looping not requested
                 return nullptr;
             }
         }
     } else {
         // there was no current item, start from end
         above = d->mModel->rootItem()->deepestItem();
 
         if (!above || !above->parent() || (above == d->mModel->rootItem())) {
             return nullptr; // folder empty
         }
     }
 
     // ok.. now below points to the previous message.
     // While it doesn't satisfy our requirements, go further up
 
     QModelIndex parentIndex = d->mModel->index(above->parent(), 0);
     QModelIndex aboveIndex = d->mModel->index(above, 0);
 
     Q_ASSERT(aboveIndex.isValid());
 
     while (
         // is not a message (we want messages, don't we ?)
         (above->type() != Item::Message) || // message filter doesn't match
         (!message_type_matches(above, messageTypeFilter)) || // we don't expand items but the item has parents unexpanded (so should be skipped)
         (
             // !expand items
             (messageTypeFilter == MessageTypeAny) && // has unexpanded parents or is itself hidden
             (!isDisplayedWithParentsExpanded(above)))
         || // is hidden
         isRowHidden(aboveIndex.row(), parentIndex) || // is not enabled or not selectable
         ((d->mModel->flags(aboveIndex) & (Qt::ItemIsSelectable | Qt::ItemIsEnabled)) != (Qt::ItemIsSelectable | Qt::ItemIsEnabled))) {
         above = above->itemAbove();
 
         if ((!above) || (above == d->mModel->rootItem())) {
             // reached the beginning
             if (loop) {
                 // looping requested
                 if (referenceItem) { // <-- this means "we have started from something that is not the beginning: looping makes sense"
                     above = d->mModel->rootItem()->deepestItem();
                 }
                 // else mi == 0 and above == 0: we have started from the end and reached the beginning (it will fail the test below and exit)
             } else {
                 // looping not requested: nothing more to do
                 return nullptr;
             }
         }
 
         if (above == referenceItem) {
             Q_ASSERT(loop);
             return nullptr; // looped and returned back to the first message
         }
 
         if (!above->parent()) {
             return nullptr;
         }
 
         parentIndex = d->mModel->index(above->parent(), 0);
         aboveIndex = d->mModel->index(above, 0);
 
         Q_ASSERT(aboveIndex.isValid());
     }
 
     return above;
 }
 
 Item *View::lastMessageItem(MessageTypeFilter messageTypeFilter)
 {
     return messageItemBefore(nullptr, messageTypeFilter, false);
 }
 
 Item *View::previousMessageItem(MessageTypeFilter messageTypeFilter, bool loop)
 {
     return messageItemBefore(currentMessageItem(false), messageTypeFilter, loop);
 }
 
 void View::growOrShrinkExistingSelection(const QModelIndex &newSelectedIndex, bool movingUp)
 {
     // Qt: why visualIndex() is private? ...I'd really need it here...
 
     int selectedVisualCoordinate = visualRect(newSelectedIndex).top();
 
     int topVisualCoordinate = 0xfffffff; // huuuuuge number
     int bottomVisualCoordinate = -(0xfffffff);
 
     QModelIndex bottomIndex;
     QModelIndex topIndex;
 
     // find out the actual selection range
     const QItemSelection selection = selectionModel()->selection();
 
     for (const QItemSelectionRange &range : selection) {
         // We're asking the model for the index as range.topLeft() and range.bottomRight()
         // can return indexes in invisible columns which have a null visualRect().
         // Column 0, instead, is always visible.
 
         QModelIndex top = d->mModel->index(range.top(), 0, range.parent());
         QModelIndex bottom = d->mModel->index(range.bottom(), 0, range.parent());
 
         if (top.isValid()) {
             if (!bottom.isValid()) {
                 bottom = top;
             }
         } else {
             if (!top.isValid()) {
                 top = bottom;
             }
         }
         int candidate = visualRect(bottom).bottom();
         if (candidate > bottomVisualCoordinate) {
             bottomVisualCoordinate = candidate;
             bottomIndex = range.bottomRight();
         }
 
         candidate = visualRect(top).top();
         if (candidate < topVisualCoordinate) {
             topVisualCoordinate = candidate;
             topIndex = range.topLeft();
         }
     }
 
     if (topIndex.isValid() && bottomIndex.isValid()) {
         if (movingUp) {
             if (selectedVisualCoordinate < topVisualCoordinate) {
                 // selecting something above the top: grow selection
                 selectionModel()->select(newSelectedIndex, QItemSelectionModel::Rows | QItemSelectionModel::Select);
             } else {
                 // selecting something below the top: shrink selection
                 const QModelIndexList selectedIndexes = selection.indexes();
                 for (const QModelIndex &idx : selectedIndexes) {
                     if ((idx.column() == 0) && (visualRect(idx).top() > selectedVisualCoordinate)) {
                         selectionModel()->select(idx, QItemSelectionModel::Rows | QItemSelectionModel::Deselect);
                     }
                 }
             }
         } else {
             if (selectedVisualCoordinate > bottomVisualCoordinate) {
                 // selecting something below bottom: grow selection
                 selectionModel()->select(newSelectedIndex, QItemSelectionModel::Rows | QItemSelectionModel::Select);
             } else {
                 // selecting something above bottom: shrink selection
                 const QModelIndexList selectedIndexes = selection.indexes();
                 for (const QModelIndex &idx : selectedIndexes) {
                     if ((idx.column() == 0) && (visualRect(idx).top() < selectedVisualCoordinate)) {
                         selectionModel()->select(idx, QItemSelectionModel::Rows | QItemSelectionModel::Deselect);
                     }
                 }
             }
         }
     } else {
         // no existing selection, just grow
         selectionModel()->select(newSelectedIndex, QItemSelectionModel::Rows | QItemSelectionModel::Select);
     }
 }
 
 bool View::selectNextMessageItem(MessageTypeFilter messageTypeFilter, ExistingSelectionBehaviour existingSelectionBehaviour, bool centerItem, bool loop)
 {
     Item *it = nextMessageItem(messageTypeFilter, loop);
     if (!it) {
         return false;
     }
 
     if (it->parent() != d->mModel->rootItem()) {
         ensureDisplayedWithParentsExpanded(it);
     }
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     switch (existingSelectionBehaviour) {
     case ExpandExistingSelection:
         selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
         selectionModel()->select(idx, QItemSelectionModel::Rows | QItemSelectionModel::Select);
         break;
     case GrowOrShrinkExistingSelection:
         selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
         growOrShrinkExistingSelection(idx, false);
         break;
     default:
         // case ClearExistingSelection:
         setCurrentIndex(idx);
         break;
     }
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 bool View::selectPreviousMessageItem(MessageTypeFilter messageTypeFilter, ExistingSelectionBehaviour existingSelectionBehaviour, bool centerItem, bool loop)
 {
     Item *it = previousMessageItem(messageTypeFilter, loop);
     if (!it) {
         return false;
     }
 
     if (it->parent() != d->mModel->rootItem()) {
         ensureDisplayedWithParentsExpanded(it);
     }
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     switch (existingSelectionBehaviour) {
     case ExpandExistingSelection:
         selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
         selectionModel()->select(idx, QItemSelectionModel::Rows | QItemSelectionModel::Select);
         break;
     case GrowOrShrinkExistingSelection:
         selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
         growOrShrinkExistingSelection(idx, true);
         break;
     default:
         // case ClearExistingSelection:
         setCurrentIndex(idx);
         break;
     }
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 bool View::focusNextMessageItem(MessageTypeFilter messageTypeFilter, bool centerItem, bool loop)
 {
     Item *it = nextMessageItem(messageTypeFilter, loop);
     if (!it) {
         return false;
     }
 
     if (it->parent() != d->mModel->rootItem()) {
         ensureDisplayedWithParentsExpanded(it);
     }
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 bool View::focusPreviousMessageItem(MessageTypeFilter messageTypeFilter, bool centerItem, bool loop)
 {
     Item *it = previousMessageItem(messageTypeFilter, loop);
     if (!it) {
         return false;
     }
 
     if (it->parent() != d->mModel->rootItem()) {
         ensureDisplayedWithParentsExpanded(it);
     }
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     selectionModel()->setCurrentIndex(idx, QItemSelectionModel::NoUpdate);
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 void View::selectFocusedMessageItem(bool centerItem)
 {
     QModelIndex idx = currentIndex();
     if (!idx.isValid()) {
         return;
     }
 
     if (selectionModel()->isSelected(idx)) {
         return;
     }
 
     selectionModel()->select(idx, QItemSelectionModel::Select | QItemSelectionModel::Current | QItemSelectionModel::Rows);
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 }
 
 bool View::selectFirstMessageItem(MessageTypeFilter messageTypeFilter, bool centerItem)
 {
     if (!storageModel()) {
         return false; // nothing to do
     }
 
     Item *it = firstMessageItem(messageTypeFilter);
     if (!it) {
         return false;
     }
 
     Q_ASSERT(it != d->mModel->rootItem()); // must never happen (obviously)
 
     ensureDisplayedWithParentsExpanded(it);
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     setCurrentIndex(idx);
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 bool View::selectLastMessageItem(MessageTypeFilter messageTypeFilter, bool centerItem)
 {
     if (!storageModel()) {
         return false;
     }
 
     Item *it = lastMessageItem(messageTypeFilter);
     if (!it) {
         return false;
     }
 
     Q_ASSERT(it != d->mModel->rootItem());
 
     ensureDisplayedWithParentsExpanded(it);
 
     QModelIndex idx = d->mModel->index(it, 0);
 
     Q_ASSERT(idx.isValid());
 
     setCurrentIndex(idx);
 
     if (centerItem) {
         scrollTo(idx, QAbstractItemView::PositionAtCenter);
     }
 
     return true;
 }
 
 void View::modelFinishedLoading()
 {
     Q_ASSERT(storageModel());
     Q_ASSERT(!d->mModel->isLoading());
 
     // nothing here for now :)
 }
 
 MessageItemSetReference View::createPersistentSet(const QList<MessageItem *> &items)
 {
     return d->mModel->createPersistentSet(items);
 }
 
 QList<MessageItem *> View::persistentSetCurrentMessageItemList(MessageItemSetReference ref)
 {
     return d->mModel->persistentSetCurrentMessageItemList(ref);
 }
 
 void View::deletePersistentSet(MessageItemSetReference ref)
 {
     d->mModel->deletePersistentSet(ref);
 }
 
 void View::markMessageItemsAsAboutToBeRemoved(const QList<MessageItem *> &items, bool bMark)
 {
     if (!bMark) {
         for (const auto mi : items) {
             if (mi->isValid()) { // hasn't been removed in the meantime
                 mi->setAboutToBeRemoved(false);
             }
         }
 
         viewport()->update();
 
         return;
     }
 
     // ok.. we're going to mark the messages as "about to be deleted".
     // This means that we're going to make them non selectable.
 
     // What happens to the selection is generally an untrackable big mess.
     // Several components and entities are involved.
 
     // Qutie tries to apply some kind of internal logic in order to keep
     // "something" selected and "something" (else) to be current.
     // The results sometimes appear to depend on the current moon phase.
 
     // The Model will do crazy things in order to preserve the current
     // selection (and possibly the current item). If it's impossible then
     // it will make its own guesses about what should be selected next.
     // A problem is that the Model will do it one message at a time.
     // When item reparenting/reordering is involved then the guesses
     // can produce non-intuitive results.
 
     // Add the fact that selection and current item are distinct concepts,
     // their relative interaction depends on the settings and is often quite
     // unclear.
 
     // Add the fact that (at the time of writing) several styles don't show
     // the current item (only Yoda knows why) and this causes some confusion to the user.
 
     // Add the fact that the operations are asynchronous: deletion will start
     // a job, do some event loop processing and then complete the work at a later time.
     // The Qutie views also tend to accumulate the changes and perform them
     // all at once at the latest possible stage.
 
     // A radical approach is needed: we FIRST deal with the selection
     // by trying to move it away from the messages about to be deleted
     // and THEN mark the (hopefully no longer selected) messages as "about to be deleted".
 
     // First of all, find out if we're going to clear the entire selection (very likely).
 
     bool clearingEntireSelection = true;
 
     const QModelIndexList selectedIndexes = selectionModel()->selectedRows(0);
 
     if (selectedIndexes.count() > items.count()) {
         // the selection is bigger: we can't clear it completely
         clearingEntireSelection = false;
     } else {
         // the selection has same size or is smaller: we can clear it completely with our removal
         for (const QModelIndex &selectedIndex : selectedIndexes) {
             Q_ASSERT(selectedIndex.isValid());
             Q_ASSERT(selectedIndex.column() == 0);
 
             Item *selectedItem = static_cast<Item *>(selectedIndex.internalPointer());
             Q_ASSERT(selectedItem);
 
             if (selectedItem->type() != Item::Message) {
                 continue;
             }
 
             if (!items.contains(static_cast<MessageItem *>(selectedItem))) {
                 // the selection contains something that we aren't going to remove:
                 // we will not clear the selection completely
                 clearingEntireSelection = false;
                 break;
             }
         }
     }
 
     if (clearingEntireSelection) {
         // Try to clear the current selection and select something sensible instead,
         // so after the deletion we will not end up with a random selection.
         // Pick up a message in the set (which is very likely to be contiguous), walk the tree
         // and select the next message that is NOT in the set.
 
         MessageItem *aMessage = items.last();
         Q_ASSERT(aMessage);
 
         // Avoid infinite loops by carrying only a limited number of attempts.
         // If there is any message that is not in the set then items.count() attempts should find it.
         int maxAttempts = items.count();
 
         while (items.contains(aMessage) && (maxAttempts > 0)) {
             Item *next = messageItemAfter(aMessage, MessageTypeAny, false);
             if (!next) {
                 // no way
                 aMessage = nullptr;
                 break;
             }
             Q_ASSERT(next->type() == Item::Message);
             aMessage = static_cast<MessageItem *>(next);
             maxAttempts--;
         }
 
         if (!aMessage) {
             // try backwards
             aMessage = items.first();
             Q_ASSERT(aMessage);
             maxAttempts = items.count();
 
             while (items.contains(aMessage) && (maxAttempts > 0)) {
                 Item *prev = messageItemBefore(aMessage, MessageTypeAny, false);
                 if (!prev) {
                     // no way
                     aMessage = nullptr;
                     break;
                 }
                 Q_ASSERT(prev->type() == Item::Message);
                 aMessage = static_cast<MessageItem *>(prev);
                 maxAttempts--;
             }
         }
 
         if (aMessage) {
             QModelIndex aMessageIndex = d->mModel->index(aMessage, 0);
             Q_ASSERT(aMessageIndex.isValid());
             Q_ASSERT(static_cast<MessageItem *>(aMessageIndex.internalPointer()) == aMessage);
             Q_ASSERT(!selectionModel()->isSelected(aMessageIndex));
             setCurrentIndex(aMessageIndex);
             selectionModel()->select(aMessageIndex, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
         }
     } // else we aren't clearing the entire selection so something should just stay selected.
 
     // Now mark messages as about to be removed.
 
     for (const auto mi : items) {
         mi->setAboutToBeRemoved(true);
         QModelIndex idx = d->mModel->index(mi, 0);
         Q_ASSERT(idx.isValid());
         Q_ASSERT(static_cast<MessageItem *>(idx.internalPointer()) == mi);
         if (selectionModel()->isSelected(idx)) {
             selectionModel()->select(idx, QItemSelectionModel::Deselect | QItemSelectionModel::Rows);
         }
     }
 
     viewport()->update();
 }
 
 void View::ensureDisplayedWithParentsExpanded(Item *it)
 {
     Q_ASSERT(it);
     Q_ASSERT(it->parent());
     Q_ASSERT(it->isViewable()); // must be attached to the viewable root
 
     if (isRowHidden(it->parent()->indexOfChildItem(it), d->mModel->index(it->parent(), 0))) {
         setRowHidden(it->parent()->indexOfChildItem(it), d->mModel->index(it->parent(), 0), false);
     }
 
     it = it->parent();
 
     while (it->parent()) {
         if (isRowHidden(it->parent()->indexOfChildItem(it), d->mModel->index(it->parent(), 0))) {
             setRowHidden(it->parent()->indexOfChildItem(it), d->mModel->index(it->parent(), 0), false);
         }
 
         QModelIndex idx = d->mModel->index(it, 0);
 
         Q_ASSERT(idx.isValid());
         Q_ASSERT(static_cast<Item *>(idx.internalPointer()) == it);
 
         if (!isExpanded(idx)) {
             setExpanded(idx, true);
         }
 
         it = it->parent();
     }
 }
 
 bool View::isDisplayedWithParentsExpanded(Item *it) const
 {
     // An item is currently viewable iff
     //  - it is marked as viewable in the item structure (that is, qt knows about its existence)
     //      (and this means that all of its parents are marked as viewable)
     //  - it is not explicitly hidden
     //  - all of its parents are expanded
 
     if (!it) {
         return false; // be nice and allow the caller not to care
     }
 
     if (!it->isViewable()) {
         return false; // item not viewable (not attached to the viewable root or qt not yet aware of it)
     }
 
     // the item and all the parents are marked as viewable.
 
     if (isRowHidden(it->parent()->indexOfChildItem(it), d->mModel->index(it->parent(), 0))) {
         return false; // item qt representation explicitly hidden
     }
 
     // the item (and theoretically all the parents) are not explicitly hidden
 
     // check the parent chain
 
     it = it->parent();
 
     while (it) {
         if (it == d->mModel->rootItem()) {
             return true; // parent is root item: ok
         }
 
         // parent is not root item
 
         if (!isExpanded(d->mModel->index(it, 0))) {
             return false; // parent is not expanded (so child not actually visible)
         }
 
         it = it->parent(); // climb up
     }
 
     // parent hierarchy interrupted somewhere
     return false;
 }
 
 bool View::isThreaded() const
 {
     if (!d->mAggregation) {
         return false;
     }
     return d->mAggregation->threading() != Aggregation::NoThreading;
 }
 
 void View::slotSelectionChanged(const QItemSelection &, const QItemSelection &)
 {
     // We assume that when selection changes, current item also changes.
     QModelIndex current = currentIndex();
 
     if (!current.isValid()) {
         d->mLastCurrentItem = nullptr;
         d->mWidget->viewMessageSelected(nullptr);
         d->mWidget->viewSelectionChanged();
         return;
     }
 
     if (!selectionModel()->isSelected(current)) {
         if (selectedIndexes().count() < 1) {
             // It may happen after row removals: Model calls this slot on currentIndex()
             // that actually might have changed "silently", without being selected.
             QItemSelection selection;
             selection.append(QItemSelectionRange(current));
             selectionModel()->select(selection, QItemSelectionModel::Select | QItemSelectionModel::Rows);
             return; // the above recurses
         } else {
             // something is still selected anyway
             // This is probably a result of CTRL+Click which unselected current: leave it as it is.
             return;
         }
     }
 
     Item *it = static_cast<Item *>(current.internalPointer());
     Q_ASSERT(it);
 
     switch (it->type()) {
     case Item::Message:
         if (d->mLastCurrentItem != it) {
             qCDebug(MESSAGELIST_LOG) << "View message selected [" << static_cast<MessageItem *>(it)->subject() << "]";
             d->mWidget->viewMessageSelected(static_cast<MessageItem *>(it));
             d->mLastCurrentItem = it;
         }
         break;
     case Item::GroupHeader:
         if (d->mLastCurrentItem) {
             d->mWidget->viewMessageSelected(nullptr);
             d->mLastCurrentItem = nullptr;
         }
         break;
     default:
         // should never happen
         Q_ASSERT(false);
         break;
     }
 
     d->mWidget->viewSelectionChanged();
 }
 
 void View::mouseDoubleClickEvent(QMouseEvent *e)
 {
     // Perform a hit test
     if (!d->mDelegate->hitTest(e->pos(), true)) {
         return;
     }
 
     // Something was hit :)
 
     Item *it = static_cast<Item *>(d->mDelegate->hitItem());
     if (!it) {
         return; // should never happen
     }
 
     switch (it->type()) {
     case Item::Message:
         // Let QTreeView handle the expansion
         QTreeView::mousePressEvent(e);
 
         switch (e->button()) {
         case Qt::LeftButton:
 
             if (d->mDelegate->hitContentItem()) {
                 // Double clicking on clickable icons does NOT activate the message
                 if (d->mDelegate->hitContentItem()->isIcon() && d->mDelegate->hitContentItem()->isClickable()) {
                     return;
                 }
             }
 
             d->mWidget->viewMessageActivated(static_cast<MessageItem *>(it));
             break;
         default:
             // make gcc happy
             break;
         }
         break;
     case Item::GroupHeader:
         // Don't let QTreeView handle the selection (as it deselects the current messages)
         switch (e->button()) {
         case Qt::LeftButton:
             if (it->childItemCount() > 0) {
                 // toggle expanded state
                 setExpanded(d->mDelegate->hitIndex(), !isExpanded(d->mDelegate->hitIndex()));
             }
             break;
         default:
             // make gcc happy
             break;
         }
         break;
     default:
         // should never happen
         Q_ASSERT(false);
         break;
     }
 }
 
 void View::changeMessageStatusRead(MessageItem *it, bool read)
 {
     Akonadi::MessageStatus set = it->status();
     Akonadi::MessageStatus unset = it->status();
     if (read) {
         set.setRead(true);
         unset.setRead(false);
     } else {
         set.setRead(false);
         unset.setRead(true);
     }
     viewport()->update();
 
     // This will actually request the widget to perform a status change on the storage.
     // The request will be then processed by the Model and the message will be updated again.
 
     d->mWidget->viewMessageStatusChangeRequest(it, set, unset);
 }
 
 void View::changeMessageStatus(MessageItem *it, Akonadi::MessageStatus set, Akonadi::MessageStatus unset)
 {
     // We first change the status of MessageItem itself. This will make the change
     // visible to the user even if the Model is actually in the middle of a long job (maybe it's loading)
     // and can't process the status change request immediately.
     // Here we actually desynchronize the cache and trust that the later call to
     // d->mWidget->viewMessageStatusChangeRequest() will really perform the status change on the storage.
     // Well... in KMail it will unless something is really screwed. Anyway, if it will not, at the next
     // load the status will be just unchanged: no animals will be harmed.
 
     qint32 stat = it->status().toQInt32();
     stat |= set.toQInt32();
     stat &= ~(unset.toQInt32());
     Akonadi::MessageStatus status;
     status.fromQInt32(stat);
     it->setStatus(status);
 
     // Trigger an update so the immediate change will be shown to the user
 
     viewport()->update();
 
     // This will actually request the widget to perform a status change on the storage.
     // The request will be then processed by the Model and the message will be updated again.
 
     d->mWidget->viewMessageStatusChangeRequest(it, set, unset);
 }
 
 void View::mousePressEvent(QMouseEvent *e)
 {
     d->mMousePressed = true;
     d->mLastMouseSource = e->source();
 
     if (d->mIsTouchEvent) {
         return;
     }
 
     d->onPressed(e);
 }
 
 void View::mouseMoveEvent(QMouseEvent *e)
 {
     if (d->mIsTouchEvent && !d->mTapAndHoldActive) {
         return;
     }
 
     if (!(e->buttons() & Qt::LeftButton)) {
         QTreeView::mouseMoveEvent(e);
         return;
     }
 
     if (d->mMousePressPosition.isNull()) {
         return;
     }
 
     if ((e->pos() - d->mMousePressPosition).manhattanLength() <= QApplication::startDragDistance()) {
         return;
     }
 
     d->mTapAndHoldActive = false;
     if (d->mRubberBand->isVisible()) {
         d->mRubberBand->hide();
     }
 
     d->mWidget->viewStartDragRequest();
 }
 
 #if 0
 void View::contextMenuEvent(QContextMenuEvent *e)
 {
     Q_UNUSED(e)
     QModelIndex index = currentIndex();
     if (index.isValid()) {
         QRect indexRect = this->visualRect(index);
         QPoint pos;
 
         if ((indexRect.isValid()) && (indexRect.bottom() > 0)) {
             if (indexRect.bottom() > viewport()->height()) {
                 if (indexRect.top() <= viewport()->height()) {
                     pos = indexRect.topLeft();
                 }
             } else {
                 pos = indexRect.bottomLeft();
             }
         }
 
         Item *item = static_cast< Item * >(index.internalPointer());
         if (item) {
             if (item->type() == Item::GroupHeader) {
                 d->mWidget->viewGroupHeaderContextPopupRequest(static_cast< GroupHeaderItem * >(item), viewport()->mapToGlobal(pos));
             } else if (!selectionEmpty()) {
                 d->mWidget->viewMessageListContextPopupRequest(selectionAsMessageItemList(), viewport()->mapToGlobal(pos));
                 e->accept();
             }
         }
     }
 }
 
 #endif
 
 void View::dragEnterEvent(QDragEnterEvent *e)
 {
     d->mWidget->viewDragEnterEvent(e);
 }
 
 void View::dragMoveEvent(QDragMoveEvent *e)
 {
     d->mWidget->viewDragMoveEvent(e);
 }
 
 void View::dropEvent(QDropEvent *e)
 {
     d->mWidget->viewDropEvent(e);
 }
 
 void View::changeEvent(QEvent *e)
 {
     switch (e->type()) {
     case QEvent::FontChange:
         d->mDelegate->generalFontChanged();
         [[fallthrough]];
     case QEvent::PaletteChange:
     case QEvent::StyleChange:
     case QEvent::LayoutDirectionChange:
     case QEvent::LocaleChange:
     case QEvent::LanguageChange:
         // All of these affect the theme's internal cache.
         setTheme(d->mTheme);
         // A layoutChanged() event will screw up the view state a bit.
         // Since this is a rare event we just reload the view.
         reload();
         break;
     default:
         // make gcc happy by default
         break;
     }
 
     QTreeView::changeEvent(e);
 }
 
 bool View::event(QEvent *e)
 {
     if (e->type() == QEvent::TouchBegin) {
         d->mIsTouchEvent = true;
         d->mMousePressed = false;
         return false;
     }
 
     if (e->type() == QEvent::Gesture) {
         d->gestureEvent(static_cast<QGestureEvent *>(e));
         e->accept();
         return true;
     }
 
     // We catch ToolTip events and pass everything else
 
     if (e->type() != QEvent::ToolTip) {
         return QTreeView::event(e);
     }
 
     if (!MessageListSettings::self()->messageToolTipEnabled()) {
         return true; // don't display tooltips
     }
 
     auto he = dynamic_cast<QHelpEvent *>(e);
     if (!he) {
         return true; // eh ?
     }
 
     QPoint pnt = viewport()->mapFromGlobal(mapToGlobal(he->pos()));
 
     if (pnt.y() < 0) {
         return true; // don't display the tooltip for items hidden under the header
     }
 
     QModelIndex idx = indexAt(pnt);
     if (!idx.isValid()) {
         return true; // may be
     }
 
     Item *it = static_cast<Item *>(idx.internalPointer());
     if (!it) {
         return true; // hum
     }
 
     Q_ASSERT(storageModel());
 
     QColor bckColor = palette().color(QPalette::ToolTipBase);
     QColor txtColor = palette().color(QPalette::ToolTipText);
     QColor darkerColor(((bckColor.red() * 8) + (txtColor.red() * 2)) / 10,
                        ((bckColor.green() * 8) + (txtColor.green() * 2)) / 10,
                        ((bckColor.blue() * 8) + (txtColor.blue() * 2)) / 10);
 
     QString bckColorName = bckColor.name();
     QString txtColorName = txtColor.name();
     QString darkerColorName = darkerColor.name();
     const bool textIsLeftToRight = (QApplication::layoutDirection() == Qt::LeftToRight);
     const QString textDirection = textIsLeftToRight ? QStringLiteral("left") : QStringLiteral("right");
 
     QString tip = QStringLiteral("<table width=\"100%\" border=\"0\" cellpadding=\"2\" cellspacing=\"0\">");
 
     switch (it->type()) {
     case Item::Message: {
         auto mi = static_cast<MessageItem *>(it);
 
         tip += QStringLiteral(
                    "<tr>"
                    "<td bgcolor=\"%1\" align=\"%4\" valign=\"middle\">"
                    "<div style=\"color: %2; font-weight: bold;\">"
                    "%3"
                    "</div>"
                    "</td>"
                    "</tr>")
                    .arg(txtColorName, bckColorName, mi->subject().toHtmlEscaped(), textDirection);
 
         tip += QLatin1StringView(
             "<tr>"
             "<td align=\"center\" valign=\"middle\">"
             "<table width=\"100%\" border=\"0\" cellpadding=\"2\" cellspacing=\"0\">");
 
         const QString htmlCodeForStandardRow = QStringLiteral(
             "<tr>"
             "<td align=\"right\" valign=\"top\" width=\"45\">"
             "<div style=\"font-weight: bold;\"><nobr>"
             "%1:"
             "</nobr></div>"
             "</td>"
             "<td align=\"left\" valign=\"top\">"
             "%2"
             "</td>"
             "</tr>");
 
         if (textIsLeftToRight) {
             tip += htmlCodeForStandardRow.arg(i18n("From"), mi->displaySender().toHtmlEscaped());
             tip += htmlCodeForStandardRow.arg(i18nc("Receiver of the email", "To"), mi->displayReceiver().toHtmlEscaped());
             tip += htmlCodeForStandardRow.arg(i18n("Date"), mi->formattedDate());
         } else {
             tip += htmlCodeForStandardRow.arg(mi->displaySender().toHtmlEscaped(), i18n("From"));
             tip += htmlCodeForStandardRow.arg(mi->displayReceiver().toHtmlEscaped(), i18nc("Receiver of the email", "To"));
             tip += htmlCodeForStandardRow.arg(mi->formattedDate(), i18n("Date"));
         }
 
         QString status = mi->statusDescription();
         const QString tags = mi->tagListDescription();
         if (!tags.isEmpty()) {
             if (!status.isEmpty()) {
                 status += QLatin1StringView(", ");
             }
             status += tags;
         }
 
         if (textIsLeftToRight) {
             tip += htmlCodeForStandardRow.arg(i18n("Status"), status);
             tip += htmlCodeForStandardRow.arg(i18n("Size"), mi->formattedSize());
             tip += htmlCodeForStandardRow.arg(i18n("Folder"), mi->folder());
         } else {
             tip += htmlCodeForStandardRow.arg(status, i18n("Status"));
             tip += htmlCodeForStandardRow.arg(mi->formattedSize(), i18n("Size"));
             tip += htmlCodeForStandardRow.arg(mi->folder(), i18n("Folder"));
         }
 
         if (mi->hasAnnotation()) {
             if (textIsLeftToRight) {
                 tip += htmlCodeForStandardRow.arg(i18n("Note"), mi->annotation().replace(QLatin1Char('\n'), QStringLiteral("<br>")));
             } else {
                 tip += htmlCodeForStandardRow.arg(mi->annotation().replace(QLatin1Char('\n'), QStringLiteral("<br>"))).arg(i18n("Note"));
             }
         }
 
         QString content = MessageList::Util::contentSummary(mi->akonadiItem());
         if (!content.trimmed().isEmpty()) {
             if (textIsLeftToRight) {
                 tip += htmlCodeForStandardRow.arg(i18n("Preview"), content.replace(QLatin1Char('\n'), QStringLiteral("<br>")));
             } else {
                 tip += htmlCodeForStandardRow.arg(content.replace(QLatin1Char('\n'), QStringLiteral("<br>"))).arg(i18n("Preview"));
             }
         }
 
         tip += QLatin1StringView(
             "</table>"
             "</td>"
             "</tr>");
 
         // FIXME: Find a way to show also CC and other header fields ?
 
         if (mi->hasChildren()) {
             Item::ChildItemStats stats;
             mi->childItemStats(stats);
 
             QString statsText;
 
             statsText = i18np("<b>%1</b> reply", "<b>%1</b> replies", mi->childItemCount());
             statsText += QLatin1StringView(", ");
 
             statsText += i18np("<b>%1</b> message in subtree (<b>%2</b> unread)",
                                "<b>%1</b> messages in subtree (<b>%2</b> unread)",
                                stats.mTotalChildCount,
                                stats.mUnreadChildCount);
 
             tip += QStringLiteral(
                        "<tr>"
                        "<td bgcolor=\"%1\" align=\"%3\" valign=\"middle\">"
                        "<nobr>%2</nobr>"
                        "</td>"
                        "</tr>")
                        .arg(darkerColorName, statsText, textDirection);
         }
 
         break;
     }
     case Item::GroupHeader: {
         auto ghi = static_cast<GroupHeaderItem *>(it);
 
         tip += QStringLiteral(
                    "<tr>"
                    "<td bgcolor=\"%1\" align=\"%4\" valign=\"middle\">"
                    "<div style=\"color: %2; font-weight: bold;\">"
                    "%3"
                    "</div>"
                    "</td>"
                    "</tr>")
                    .arg(txtColorName, bckColorName, ghi->label(), textDirection);
 
         QString description;
 
         switch (d->mAggregation->grouping()) {
         case Aggregation::GroupByDate:
             if (d->mAggregation->threading() != Aggregation::NoThreading) {
                 switch (d->mAggregation->threadLeader()) {
                 case Aggregation::TopmostMessage:
                     if (ghi->label().contains(QRegularExpression(QStringLiteral("[0-9]")))) {
                         description = i18nc("@info:tooltip Formats to something like 'Threads started on 2008-12-21'", "Threads started on %1", ghi->label());
                     } else {
                         description = i18nc("@info:tooltip Formats to something like 'Threads started Yesterday'", "Threads started %1", ghi->label());
                     }
                     break;
                 case Aggregation::MostRecentMessage:
                     description = i18n("Threads with messages dated %1", ghi->label());
                     break;
                 default:
                     // nuthin, make gcc happy
                     break;
                 }
             } else {
                 static const QRegularExpression reg(QStringLiteral("[0-9]"));
                 if (ghi->label().contains(reg)) {
                     if (storageModel()->containsOutboundMessages()) {
                         description = i18nc("@info:tooltip Formats to something like 'Messages sent on 2008-12-21'", "Messages sent on %1", ghi->label());
                     } else {
                         description =
                             i18nc("@info:tooltip Formats to something like 'Messages received on 2008-12-21'", "Messages received on %1", ghi->label());
                     }
                 } else {
                     if (storageModel()->containsOutboundMessages()) {
                         description = i18nc("@info:tooltip Formats to something like 'Messages sent Yesterday'", "Messages sent %1", ghi->label());
                     } else {
                         description = i18nc("@info:tooltip Formats to something like 'Messages received Yesterday'", "Messages received %1", ghi->label());
                     }
                 }
             }
             break;
         case Aggregation::GroupByDateRange:
             if (d->mAggregation->threading() != Aggregation::NoThreading) {
                 switch (d->mAggregation->threadLeader()) {
                 case Aggregation::TopmostMessage:
                     description = i18n("Threads started within %1", ghi->label());
                     break;
                 case Aggregation::MostRecentMessage:
                     description = i18n("Threads containing messages with dates within %1", ghi->label());
                     break;
                 default:
                     // nuthin, make gcc happy
                     break;
                 }
             } else {
                 if (storageModel()->containsOutboundMessages()) {
                     description = i18n("Messages sent within %1", ghi->label());
                 } else {
                     description = i18n("Messages received within %1", ghi->label());
                 }
             }
             break;
         case Aggregation::GroupBySenderOrReceiver:
         case Aggregation::GroupBySender:
             if (d->mAggregation->threading() != Aggregation::NoThreading) {
                 switch (d->mAggregation->threadLeader()) {
                 case Aggregation::TopmostMessage:
                     description = i18n("Threads started by %1", ghi->label());
                     break;
                 case Aggregation::MostRecentMessage:
                     description = i18n("Threads with most recent message by %1", ghi->label());
                     break;
                 default:
                     // nuthin, make gcc happy
                     break;
                 }
             } else {
                 if (storageModel()->containsOutboundMessages()) {
                     if (d->mAggregation->grouping() == Aggregation::GroupBySenderOrReceiver) {
                         description = i18n("Messages sent to %1", ghi->label());
                     } else {
                         description = i18n("Messages sent by %1", ghi->label());
                     }
                 } else {
                     description = i18n("Messages received from %1", ghi->label());
                 }
             }
             break;
         case Aggregation::GroupByReceiver:
             if (d->mAggregation->threading() != Aggregation::NoThreading) {
                 switch (d->mAggregation->threadLeader()) {
                 case Aggregation::TopmostMessage:
                     description = i18n("Threads directed to %1", ghi->label());
                     break;
                 case Aggregation::MostRecentMessage:
                     description = i18n("Threads with most recent message directed to %1", ghi->label());
                     break;
                 default:
                     // nuthin, make gcc happy
                     break;
                 }
             } else {
                 if (storageModel()->containsOutboundMessages()) {
                     description = i18n("Messages sent to %1", ghi->label());
                 } else {
                     description = i18n("Messages received by %1", ghi->label());
                 }
             }
             break;
         default:
             // nuthin, make gcc happy
             break;
         }
 
         if (!description.isEmpty()) {
             tip += QStringLiteral(
                        "<tr>"
                        "<td align=\"%2\" valign=\"middle\">"
                        "%1"
                        "</td>"
                        "</tr>")
                        .arg(description, textDirection);
         }
 
         if (ghi->hasChildren()) {
             Item::ChildItemStats stats;
             ghi->childItemStats(stats);
 
             QString statsText;
 
             if (d->mAggregation->threading() != Aggregation::NoThreading) {
                 statsText = i18np("<b>%1</b> thread", "<b>%1</b> threads", ghi->childItemCount());
                 statsText += QLatin1StringView(", ");
             }
 
             statsText +=
                 i18np("<b>%1</b> message (<b>%2</b> unread)", "<b>%1</b> messages (<b>%2</b> unread)", stats.mTotalChildCount, stats.mUnreadChildCount);
 
             tip += QStringLiteral(
                        "<tr>"
                        "<td bgcolor=\"%1\" align=\"%3\" valign=\"middle\">"
                        "<nobr>%2</nobr>"
                        "</td>"
                        "</tr>")
                        .arg(darkerColorName, statsText, textDirection);
         }
 
         break;
     }
     default:
         // nuthin (just make gcc happy for now)
         break;
     }
 
     tip += QLatin1StringView("</table>");
 
     QToolTip::showText(he->globalPos(), tip, viewport(), visualRect(idx));
 
     return true;
 }
 
 void View::slotExpandAllThreads()
 {
     setAllThreadsExpanded(true);
 }
 
 void View::slotCollapseAllThreads()
 {
     setAllThreadsExpanded(false);
 }
 
 void View::slotCollapseAllGroups()
 {
     setAllGroupsExpanded(false);
 }
 
 void View::slotExpandAllGroups()
 {
     setAllGroupsExpanded(true);
 }
 
 void View::slotCollapseCurrentItem()
 {
     setCurrentThreadExpanded(false);
 }
 
 void View::slotExpandCurrentItem()
 {
     setCurrentThreadExpanded(true);
 }
 
 void View::focusQuickSearch(const QString &selectedText)
 {
     d->mWidget->focusQuickSearch(selectedText);
 }
 
 QList<Akonadi::MessageStatus> View::currentFilterStatus() const
 {
     return d->mWidget->currentFilterStatus();
 }
 
 MessageList::Core::QuickSearchLine::SearchOptions View::currentOptions() const
 {
     return d->mWidget->currentOptions();
 }
 
 QString View::currentFilterSearchString() const
 {
     return d->mWidget->currentFilterSearchString();
 }
 
 void View::setRowHidden(int row, const QModelIndex &parent, bool hide)
 {
     const QModelIndex rowModelIndex = model()->index(row, 0, parent);
     const Item *const rowItem = static_cast<Item *>(rowModelIndex.internalPointer());
 
     if (rowItem) {
         const bool currentlyHidden = isRowHidden(row, parent);
 
         if (currentlyHidden != hide) {
             if (currentMessageItem() == rowItem) {
                 selectionModel()->clear();
                 selectionModel()->clearSelection();
             }
         }
     }
 
     QTreeView::setRowHidden(row, parent, hide);
 }
 
 void View::sortOrderMenuAboutToShow(QMenu *menu)
 {
     d->mWidget->sortOrderMenuAboutToShow(menu);
 }
 
 void View::aggregationMenuAboutToShow(QMenu *menu)
 {
     d->mWidget->aggregationMenuAboutToShow(menu);
 }
 
 void View::themeMenuAboutToShow(QMenu *menu)
 {
     d->mWidget->themeMenuAboutToShow(menu);
 }
 
 void View::setCollapseItem(const QModelIndex &index)
 {
     if (index.isValid()) {
         setExpanded(index, false);
     }
 }
 
 void View::setExpandItem(const QModelIndex &index)
 {
     if (index.isValid()) {
         setExpanded(index, true);
     }
 }
 
 void View::setQuickSearchClickMessage(const QString &msg)
 {
     d->mWidget->quickSearch()->setPlaceholderText(msg);
 }
 
 void View::ViewPrivate::onPressed(QMouseEvent *e)
 {
     mMousePressPosition = QPoint();
 
     // Perform a hit test
     if (!mDelegate->hitTest(e->pos(), true)) {
         return;
     }
 
     // Something was hit :)
 
     Item *it = static_cast<Item *>(mDelegate->hitItem());
     if (!it) {
         return; // should never happen
     }
 
     // Abort any pending message pre-selection as the user is probably
     // already navigating the view (so pre-selection would make his view jump
     // to an unexpected place).
     mModel->setPreSelectionMode(PreSelectNone);
 
     switch (it->type()) {
     case Item::Message:
         mMousePressPosition = e->pos();
 
         switch (e->button()) {
         case Qt::LeftButton:
             // if we have multi selection then the meaning of hitting
             // the content item is quite unclear.
             if (mDelegate->hitContentItem() && (q->selectedIndexes().count() > 1)) {
                 qCDebug(MESSAGELIST_LOG) << "Left hit with selectedIndexes().count() == " << q->selectedIndexes().count();
 
                 switch (mDelegate->hitContentItem()->type()) {
                 case Theme::ContentItem::AnnotationIcon:
                     static_cast<MessageItem *>(it)->editAnnotation(q);
                     return; // don't select the item
                     break;
                 case Theme::ContentItem::ActionItemStateIcon:
                     q->changeMessageStatus(static_cast<MessageItem *>(it),
                                            it->status().isToAct() ? Akonadi::MessageStatus() : Akonadi::MessageStatus::statusToAct(),
                                            it->status().isToAct() ? Akonadi::MessageStatus::statusToAct() : Akonadi::MessageStatus());
                     return; // don't select the item
                     break;
                 case Theme::ContentItem::ImportantStateIcon:
                     q->changeMessageStatus(static_cast<MessageItem *>(it),
                                            it->status().isImportant() ? Akonadi::MessageStatus() : Akonadi::MessageStatus::statusImportant(),
                                            it->status().isImportant() ? Akonadi::MessageStatus::statusImportant() : Akonadi::MessageStatus());
                     return; // don't select the item
                 case Theme::ContentItem::ReadStateIcon:
                     q->changeMessageStatusRead(static_cast<MessageItem *>(it), it->status().isRead() ? false : true);
                     return;
                     break;
                 case Theme::ContentItem::SpamHamStateIcon:
                     q->changeMessageStatus(static_cast<MessageItem *>(it),
                                            it->status().isSpam()
                                                ? Akonadi::MessageStatus()
                                                : (it->status().isHam() ? Akonadi::MessageStatus::statusSpam() : Akonadi::MessageStatus::statusHam()),
                                            it->status().isSpam() ? Akonadi::MessageStatus::statusSpam()
                                                                  : (it->status().isHam() ? Akonadi::MessageStatus::statusHam() : Akonadi::MessageStatus()));
                     return; // don't select the item
                     break;
                 case Theme::ContentItem::WatchedIgnoredStateIcon:
                     q->changeMessageStatus(static_cast<MessageItem *>(it),
                                            it->status().isIgnored()
                                                ? Akonadi::MessageStatus()
                                                : (it->status().isWatched() ? Akonadi::MessageStatus::statusIgnored() : Akonadi::MessageStatus::statusWatched()),
                                            it->status().isIgnored()
                                                ? Akonadi::MessageStatus::statusIgnored()
                                                : (it->status().isWatched() ? Akonadi::MessageStatus::statusWatched() : Akonadi::MessageStatus()));
                     return; // don't select the item
                     break;
                 default:
                     // make gcc happy
                     break;
                 }
             }
 
             // Let QTreeView handle the selection and Q_EMIT the appropriate signals (slotSelectionChanged() may be called)
             q->QTreeView::mousePressEvent(e);
 
             break;
         case Qt::RightButton:
             // Let QTreeView handle the selection and Q_EMIT the appropriate signals (slotSelectionChanged() may be called)
             q->QTreeView::mousePressEvent(e);
             e->accept();
             mWidget->viewMessageListContextPopupRequest(q->selectionAsMessageItemList(), q->viewport()->mapToGlobal(e->pos()));
 
             break;
         default:
             // make gcc happy
             break;
         }
         break;
     case Item::GroupHeader: {
         // Don't let QTreeView handle the selection (as it deselects the current messages)
         auto groupHeaderItem = static_cast<GroupHeaderItem *>(it);
 
         switch (e->button()) {
         case Qt::LeftButton: {
             QModelIndex index = mModel->index(groupHeaderItem, 0);
 
             if (index.isValid()) {
                 q->setCurrentIndex(index);
             }
 
             if (!mDelegate->hitContentItem()) {
                 return;
             }
 
             if (mDelegate->hitContentItem()->type() == Theme::ContentItem::ExpandedStateIcon) {
                 if (groupHeaderItem->childItemCount() > 0) {
                     // toggle expanded state
                     q->setExpanded(mDelegate->hitIndex(), !q->isExpanded(mDelegate->hitIndex()));
                 }
             }
             break;
         }
         case Qt::RightButton:
             mWidget->viewGroupHeaderContextPopupRequest(groupHeaderItem, q->viewport()->mapToGlobal(e->pos()));
             break;
         default:
             // make gcc happy
             break;
         }
         break;
     }
     default:
         // should never happen
         Q_ASSERT(false);
         break;
     }
 }
 
 void View::ViewPrivate::gestureEvent(QGestureEvent *e)
 {
     if (QGesture *gesture = e->gesture(Qt::TapGesture)) {
         tapTriggered(static_cast<QTapGesture *>(gesture));
     }
     if (QGesture *gesture = e->gesture(Qt::TapAndHoldGesture)) {
         tapAndHoldTriggered(static_cast<QTapAndHoldGesture *>(gesture));
     }
     if (QGesture *gesture = e->gesture(mTwoFingerTap)) {
         twoFingerTapTriggered(static_cast<KTwoFingerTap *>(gesture));
     }
 }
 
 void View::ViewPrivate::tapTriggered(QTapGesture *tap)
 {
     static bool scrollerWasScrolling = false;
 
     if (tap->state() == Qt::GestureStarted) {
         mTapAndHoldActive = false;
 
         // if QScroller state is Scrolling or Dragging, the user makes the tap to stop the scrolling
         if (mScroller->state() == QScroller::Scrolling || mScroller->state() == QScroller::Dragging) {
             scrollerWasScrolling = true;
         } else if (mScroller->state() == QScroller::Pressed || mScroller->state() == QScroller::Inactive) {
             scrollerWasScrolling = false;
         }
     }
 
     if (tap->state() == Qt::GestureFinished && !scrollerWasScrolling) {
         mIsTouchEvent = false;
 
         // with touch you can touch multiple widgets at the same time, but only one widget will get a mousePressEvent.
         // we use this to select the right window
         if (!mMousePressed) {
             return;
         }
 
         if (mRubberBand->isVisible()) {
             mRubberBand->hide();
         }
 
         // simulate a mousePressEvent, to allow QTreeView to select the items
         QMouseEvent fakeMousePress(QEvent::MouseButtonPress,
                                    tap->position(),
                                    q->viewport()->mapToGlobal(tap->position()),
                                    mTapAndHoldActive ? Qt::RightButton : Qt::LeftButton,
                                    mTapAndHoldActive ? Qt::RightButton : Qt::LeftButton,
                                    Qt::NoModifier);
 
         onPressed(&fakeMousePress);
         mTapAndHoldActive = false;
     }
 
     if (tap->state() == Qt::GestureCanceled) {
         mIsTouchEvent = false;
         if (mRubberBand->isVisible()) {
             mRubberBand->hide();
         }
         mTapAndHoldActive = false;
     }
 }
 
 void View::ViewPrivate::tapAndHoldTriggered(QTapAndHoldGesture *tap)
 {
     if (tap->state() == Qt::GestureFinished) {
         // with touch you can touch multiple widgets at the same time, but only one widget will get a mousePressEvent.
         // we use this to select the right window
         if (!mMousePressed) {
             return;
         }
 
         // the TapAndHoldGesture is triggerable the with mouse, we don't want this
         if (mLastMouseSource == Qt::MouseEventNotSynthesized) {
             return;
         }
 
         // the TapAndHoldGesture is triggerable the with stylus, we don't want this
         if (!mIsTouchEvent) {
             return;
         }
 
         mTapAndHoldActive = true;
         mScroller->stop();
 
         // simulate a mousePressEvent, to allow QTreeView to select the items
         const QPoint tapViewportPos(q->viewport()->mapFromGlobal(tap->position().toPoint()));
         QMouseEvent fakeMousePress(QEvent::MouseButtonPress, tapViewportPos, tapViewportPos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
         onPressed(&fakeMousePress);
 
         const QPoint tapIndicatorSize(80, 80); // size for the tapAndHold indicator
         const QPoint pos(q->mapFromGlobal(tap->position().toPoint()));
         const QRect tapIndicatorRect(pos - (tapIndicatorSize / 2), pos + (tapIndicatorSize / 2));
         mRubberBand->setGeometry(tapIndicatorRect.normalized());
         mRubberBand->show();
     }
 }
 
 void View::ViewPrivate::twoFingerTapTriggered(KTwoFingerTap *tap)
 {
     if (tap->state() == Qt::GestureFinished) {
         if (mTapAndHoldActive) {
             return;
         }
 
         // with touch you can touch multiple widgets at the same time, but only one widget will get a mousePressEvent.
         // we use this to select the right window
         if (!mMousePressed) {
             return;
         }
 
         // simulate a mousePressEvent with Qt::ControlModifier, to allow QTreeView to select the items
         QMouseEvent fakeMousePress(QEvent::MouseButtonPress,
                                    tap->pos(),
                                    q->viewport()->mapToGlobal(tap->pos()),
                                    Qt::LeftButton,
                                    Qt::LeftButton,
                                    Qt::ControlModifier);
         onPressed(&fakeMousePress);
     }
 }
 
 #include "moc_view.cpp"