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/widgetbase.h"
 #include "core/aggregation.h"
 #include "core/filter.h"
 #include "core/filtersavedmanager.h"
 #include "core/manager.h"
 #include "core/messageitem.h"
 #include "core/model.h"
 #include "core/optionset.h"
 #include "core/storagemodelbase.h"
 #include "core/theme.h"
 #include "core/view.h"
 #include "core/widgets/quicksearchwarning.h"
 #include "core/widgets/searchcollectionindexingwarning.h"
 #include "core/widgets/tablockedwarning.h"
 #include "messagelistsettings.h"
 #include "widgets/searchlinestatus.h"
 
 #include "utils/configureaggregationsdialog.h"
 #include "utils/configurethemesdialog.h"
 
 #include <QActionGroup>
 #include <QHeaderView>
 #include <QPointer>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QVariant>
 
 #include "messagelist_debug.h"
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <QAction>
 #include <QComboBox>
 #include <QMenu>
 
 #include "core/widgets/filternamedialog.h"
 #include <Akonadi/Collection>
 #include <Akonadi/MessageStatus>
 #include <chrono>
 
 using namespace std::chrono_literals;
 
 using namespace MessageList::Core;
 
 class Widget::WidgetPrivate
 {
 public:
     WidgetPrivate(Widget *owner)
         : q(owner)
     {
     }
 
     /**
      * Small helper for switching SortOrder::MessageSorting and SortOrder::SortDirection
      * on the fly.
      * After doing this, the sort indicator in the header is updated.
      */
     void switchMessageSorting(SortOrder::MessageSorting messageSorting, SortOrder::SortDirection sortDirection, int logicalHeaderColumnIndex);
 
     /**
      * Check if our sort order can still be used with this aggregation.
      * This can happen if the global aggregation changed, for example we can now
      * have "most recent in subtree" sorting with an aggregation without threading.
      * If this happens, reset to the default sort order and don't use the global sort
      * order.
      */
     void checkSortOrder(const StorageModel *storageModel);
 
     void setDefaultAggregationForStorageModel(const StorageModel *storageModel);
     void setDefaultThemeForStorageModel(const StorageModel *storageModel);
     void setDefaultSortOrderForStorageModel(const StorageModel *storageModel);
     void applyFilter();
 
     Widget *const q;
 
     QuickSearchWarning *quickSearchWarning = nullptr;
     SearchCollectionIndexingWarning *searchCollectionIndexingWarning = nullptr;
     TabLockedWarning *tabLockedWarning = nullptr;
     QuickSearchLine *quickSearchLine = nullptr;
     View *mView = nullptr;
     QString mLastAggregationId;
     QString mLastThemeId;
     QTimer *mSearchTimer = nullptr;
     StorageModel *mStorageModel = nullptr; ///< The currently displayed storage. The storage itself
     ///  is owned by MessageList::Widget.
     Aggregation *mAggregation = nullptr; ///< The currently set aggregation mode, a deep copy
     Theme *mTheme = nullptr; ///< The currently set theme, a deep copy
     SortOrder mSortOrder; ///< The currently set sort order
     Filter *mFilter = nullptr; ///< The currently applied filter, owned by us.
     bool mStorageUsesPrivateTheme = false; ///< true if the current folder does not use the global theme
     bool mStorageUsesPrivateAggregation = false; ///< true if the current folder does not use the global aggregation
     bool mStorageUsesPrivateSortOrder = false; ///< true if the current folder does not use the global sort order
     Akonadi::Collection mCurrentFolder; ///< The current folder
     int mCurrentStatusFilterIndex = 0;
     bool mStatusFilterComboPopulationInProgress = false;
     bool mLockTab = false;
 };
 
 Widget::Widget(QWidget *pParent)
     : QWidget(pParent)
     , d(new WidgetPrivate(this))
 {
     Manager::registerWidget(this);
     connect(Manager::instance(), &Manager::aggregationsChanged, this, &Widget::aggregationsChanged);
     connect(Manager::instance(), &Manager::themesChanged, this, &Widget::themesChanged);
 
     setAutoFillBackground(true);
     setObjectName(QLatin1StringView("messagelistwidget"));
 
     auto g = new QVBoxLayout(this);
     g->setContentsMargins({});
     g->setSpacing(0);
 
     d->quickSearchLine = new QuickSearchLine;
     d->quickSearchLine->setObjectName(QLatin1StringView("quicksearchline"));
     connect(d->quickSearchLine, &QuickSearchLine::clearButtonClicked, this, &Widget::searchEditClearButtonClicked);
 
     connect(d->quickSearchLine, &QuickSearchLine::searchEditTextEdited, this, &Widget::searchEditTextEdited);
     connect(d->quickSearchLine, &QuickSearchLine::searchOptionChanged, this, &Widget::searchEditTextEdited);
     connect(d->quickSearchLine, &QuickSearchLine::statusButtonsClicked, this, &Widget::slotStatusButtonsClicked);
     connect(d->quickSearchLine, &QuickSearchLine::forceLostFocus, this, &Widget::forceLostFocus);
     connect(d->quickSearchLine, &QuickSearchLine::saveFilter, this, &Widget::slotSaveFilter);
     connect(d->quickSearchLine, &QuickSearchLine::activateFilter, this, &Widget::slotActivateFilter);
     g->addWidget(d->quickSearchLine, 0);
     d->quickSearchWarning = new QuickSearchWarning(this);
     g->addWidget(d->quickSearchWarning, 0);
     d->searchCollectionIndexingWarning = new SearchCollectionIndexingWarning(this);
     g->addWidget(d->searchCollectionIndexingWarning, 0);
 
     d->tabLockedWarning = new TabLockedWarning(this);
     g->addWidget(d->tabLockedWarning, 0);
     connect(d->tabLockedWarning, &TabLockedWarning::unlockTabRequested, this, [this]() {
         setLockTab(false);
         Q_EMIT unlockTabRequested();
         // Fix icon!
     });
 
     d->mView = new View(this);
     d->mView->setFrameStyle(QFrame::NoFrame);
     d->mView->setSortOrder(&d->mSortOrder);
     d->mView->setObjectName(QLatin1StringView("messagealistview"));
     g->addWidget(d->mView, 1);
 
     connect(d->mView->header(), &QHeaderView::sectionClicked, this, &Widget::slotViewHeaderSectionClicked);
     d->mSearchTimer = nullptr;
 }
 
 Widget::~Widget()
 {
     d->mView->setStorageModel(nullptr);
 
     Manager::unregisterWidget(this);
 
     delete d->mSearchTimer;
     delete d->mTheme;
     delete d->mAggregation;
     delete d->mFilter;
     delete d->mStorageModel;
 }
 
 void Widget::slotActivateFilter(Filter *f)
 {
     setFilter(f);
     d->quickSearchLine->searchEdit()->setText(f->searchString());
     d->quickSearchLine->setSearchOptions(f->currentOptions());
     d->quickSearchLine->setFilterMessageStatus(f->status());
 }
 
 void Widget::slotSaveFilter()
 {
     if (d->mFilter) {
         QPointer<FilterNameDialog> dlg = new FilterNameDialog(this);
         dlg->setExistingFilterNames(FilterSavedManager::self()->existingFilterNames());
         if (dlg->exec()) {
             FilterSavedManager::self()->saveFilter(d->mFilter, dlg->filterName(), dlg->iconName());
         }
         delete dlg;
     } else {
         KMessageBox::information(this, i18n("Any filter defined."), i18nc("@title:window", "Create Filter"));
     }
 }
 
 void Widget::changeQuicksearchVisibility(bool show)
 {
     QLineEdit *const lineEdit = d->quickSearchLine->searchEdit();
     if (!show) {
         // if we hide it we do not want to apply the filter,
         // otherwise someone is maybe stuck with x new emails
         // and cannot read it because of filter
         lineEdit->clear();
 
         // we focus the message list if we hide the searchbar
         d->mView->setFocus(Qt::OtherFocusReason);
     } else {
         // on show: we focus the lineedit for fast filtering
         lineEdit->setFocus(Qt::OtherFocusReason);
         if (d->mFilter) {
             resetFilter();
         }
     }
     d->quickSearchLine->changeQuicksearchVisibility(show);
     MessageListSettings::self()->setShowQuickSearch(show);
 }
 
 void Widget::populateStatusFilterCombo()
 {
     if (d->mStatusFilterComboPopulationInProgress) {
         return;
     }
     d->mStatusFilterComboPopulationInProgress = true;
     QComboBox *tagFilterComboBox = d->quickSearchLine->tagFilterComboBox();
     d->mCurrentStatusFilterIndex = (tagFilterComboBox->currentIndex() != -1) ? tagFilterComboBox->currentIndex() : 0;
     disconnect(tagFilterComboBox, &QComboBox::currentIndexChanged, this, &Widget::statusSelected);
 
     tagFilterComboBox->clear();
 
     fillMessageTagCombo();
 }
 
 void Widget::addMessageTagItem(const QPixmap &icon, const QString &text, const QVariant &data)
 {
     d->quickSearchLine->tagFilterComboBox()->addItem(icon, text, data);
 }
 
 void Widget::setCurrentStatusFilterItem()
 {
     d->quickSearchLine->updateComboboxVisibility();
     connect(d->quickSearchLine->tagFilterComboBox(), &QComboBox::currentIndexChanged, this, &Widget::statusSelected);
     d->quickSearchLine->tagFilterComboBox()->setCurrentIndex(
         d->mCurrentStatusFilterIndex >= d->quickSearchLine->tagFilterComboBox()->count() ? 0 : d->mCurrentStatusFilterIndex);
     d->mStatusFilterComboPopulationInProgress = false;
 }
 
 MessageItem *Widget::currentMessageItem() const
 {
     return view()->currentMessageItem();
 }
 
 MessageList::Core::QuickSearchLine::SearchOptions Widget::currentOptions() const
 {
     return d->quickSearchLine->searchOptions();
 }
 
 QList<Akonadi::MessageStatus> Widget::currentFilterStatus() const
 {
     if (d->mFilter) {
         return d->mFilter->status();
     }
     return {};
 }
 
 QString Widget::currentFilterSearchString() const
 {
     if (d->mFilter) {
         return d->mFilter->searchString();
     }
     return {};
 }
 
 QString Widget::currentFilterTagId() const
 {
     if (d->mFilter) {
         return d->mFilter->tagId();
     }
 
     return {};
 }
 
 void Widget::WidgetPrivate::setDefaultAggregationForStorageModel(const StorageModel *storageModel)
 {
     const Aggregation *opt = Manager::instance()->aggregationForStorageModel(storageModel, &mStorageUsesPrivateAggregation);
 
     Q_ASSERT(opt);
 
     delete mAggregation;
     mAggregation = new Aggregation(*opt);
 
     mView->setAggregation(mAggregation);
 
     mLastAggregationId = opt->id();
 }
 
 void Widget::WidgetPrivate::setDefaultThemeForStorageModel(const StorageModel *storageModel)
 {
     const Theme *opt = Manager::instance()->themeForStorageModel(storageModel, &mStorageUsesPrivateTheme);
 
     Q_ASSERT(opt);
 
     delete mTheme;
     mTheme = new Theme(*opt);
 
     mView->setTheme(mTheme);
 
     mLastThemeId = opt->id();
 }
 
 void Widget::WidgetPrivate::checkSortOrder(const StorageModel *storageModel)
 {
     if (storageModel && mAggregation && !mSortOrder.validForAggregation(mAggregation)) {
         qCDebug(MESSAGELIST_LOG) << "Could not restore sort order for folder" << storageModel->id();
         mSortOrder = SortOrder::defaultForAggregation(mAggregation, mSortOrder);
 
         // Change the global sort order if the sort order didn't fit the global aggregation.
         // Otherwise, if it is a per-folder aggregation, make the sort order per-folder too.
         if (mStorageUsesPrivateAggregation) {
             mStorageUsesPrivateSortOrder = true;
         }
         if (mStorageModel) {
             Manager::instance()->saveSortOrderForStorageModel(storageModel, mSortOrder, mStorageUsesPrivateSortOrder);
         }
         switchMessageSorting(mSortOrder.messageSorting(), mSortOrder.messageSortDirection(), -1);
     }
 }
 
 void Widget::WidgetPrivate::setDefaultSortOrderForStorageModel(const StorageModel *storageModel)
 {
     // Load the sort order from config and update column headers
     mSortOrder = Manager::instance()->sortOrderForStorageModel(storageModel, &mStorageUsesPrivateSortOrder);
     switchMessageSorting(mSortOrder.messageSorting(), mSortOrder.messageSortDirection(), -1);
     checkSortOrder(storageModel);
 }
 
 void Widget::saveCurrentSelection()
 {
     if (d->mStorageModel) {
         // Save the current selection
         MessageItem *lastSelectedMessageItem = d->mView->currentMessageItem(false);
         if (lastSelectedMessageItem) {
             d->mStorageModel->savePreSelectedMessage(lastSelectedMessageItem->uniqueId());
         }
     }
 }
 
 void Widget::setStorageModel(StorageModel *storageModel, PreSelectionMode preSelectionMode)
 {
     if (storageModel == d->mStorageModel) {
         return; // nuthin to do here
     }
 
     d->setDefaultAggregationForStorageModel(storageModel);
     d->setDefaultThemeForStorageModel(storageModel);
     d->setDefaultSortOrderForStorageModel(storageModel);
 
     if (!d->quickSearchLine->searchEdit()->locked()) {
         if (d->mSearchTimer) {
             d->mSearchTimer->stop();
             delete d->mSearchTimer;
             d->mSearchTimer = nullptr;
         }
 
         d->quickSearchLine->searchEdit()->clear();
 
         if (d->mFilter) {
             resetFilter();
         }
     }
     StorageModel *oldModel = d->mStorageModel;
 
     d->mStorageModel = storageModel;
     d->mView->setStorageModel(d->mStorageModel, preSelectionMode);
 
     delete oldModel;
 
     d->quickSearchLine->tagFilterComboBox()->setEnabled(d->mStorageModel);
     d->quickSearchLine->searchEdit()->setEnabled(d->mStorageModel);
     d->quickSearchLine->setContainsOutboundMessages(d->mStorageModel->containsOutboundMessages());
 }
 
 StorageModel *Widget::storageModel() const
 {
     return d->mStorageModel;
 }
 
 QLineEdit *Widget::quickSearch() const
 {
     return d->quickSearchLine->searchEdit();
 }
 
 View *Widget::view() const
 {
     return d->mView;
 }
 
 void Widget::themeMenuAboutToShow()
 {
     if (!d->mStorageModel) {
         return;
     }
 
     auto menu = qobject_cast<QMenu *>(sender());
     if (!menu) {
         return;
     }
     themeMenuAboutToShow(menu);
 }
 
 void Widget::themeMenuAboutToShow(QMenu *menu)
 {
     menu->clear();
 
     menu->addSection(i18n("Theme"));
 
     auto grp = new QActionGroup(menu);
 
     QList<Theme *> sortedThemes = Manager::instance()->themes().values();
 
     QAction *act;
 
     std::sort(sortedThemes.begin(), sortedThemes.end(), MessageList::Core::Theme::compareName);
 
     for (const auto theme : std::as_const(sortedThemes)) {
         act = menu->addAction(theme->name());
         act->setCheckable(true);
         grp->addAction(act);
         act->setChecked(d->mLastThemeId == theme->id());
         act->setData(QVariant(theme->id()));
         connect(act, &QAction::triggered, this, &Widget::themeSelected);
     }
 
     menu->addSeparator();
 
     act = menu->addAction(i18n("Configure..."));
     connect(act, &QAction::triggered, this, &Widget::configureThemes);
 }
 
 void Widget::setPrivateSortOrderForStorage()
 {
     if (!d->mStorageModel) {
         return;
     }
 
     d->mStorageUsesPrivateSortOrder = !d->mStorageUsesPrivateSortOrder;
 
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 }
 
 void Widget::configureThemes()
 {
     auto dialog = new Utils::ConfigureThemesDialog(window());
     dialog->selectTheme(d->mLastThemeId);
     dialog->show();
 }
 
 void Widget::themeSelected(bool)
 {
     if (!d->mStorageModel) {
         return; // nuthin to do
     }
 
     auto act = qobject_cast<QAction *>(sender());
     if (!act) {
         return;
     }
 
     QVariant v = act->data();
     const QString id = v.toString();
 
     if (id.isEmpty()) {
         return;
     }
 
     const Theme *opt = Manager::instance()->theme(id);
 
     delete d->mTheme;
     d->mTheme = new Theme(*opt);
 
     d->mView->setTheme(d->mTheme);
 
     d->mLastThemeId = opt->id();
 
     // mStorageUsesPrivateTheme = false;
 
     Manager::instance()->saveThemeForStorageModel(d->mStorageModel, opt->id(), d->mStorageUsesPrivateTheme);
 
     d->mView->reload();
 }
 
 void Widget::aggregationMenuAboutToShow()
 {
     auto menu = qobject_cast<QMenu *>(sender());
     if (!menu) {
         return;
     }
     aggregationMenuAboutToShow(menu);
 }
 
 void Widget::aggregationMenuAboutToShow(QMenu *menu)
 {
     menu->clear();
 
     menu->addSection(i18n("Aggregation"));
 
     auto grp = new QActionGroup(menu);
 
     QList<Aggregation *> sortedAggregations = Manager::instance()->aggregations().values();
 
     QAction *act;
 
     std::sort(sortedAggregations.begin(), sortedAggregations.end(), MessageList::Core::Aggregation::compareName);
 
     for (const auto agg : std::as_const(sortedAggregations)) {
         act = menu->addAction(agg->name());
         act->setCheckable(true);
         grp->addAction(act);
         act->setChecked(d->mLastAggregationId == agg->id());
         act->setData(QVariant(agg->id()));
         connect(act, &QAction::triggered, this, &Widget::aggregationSelected);
     }
 
     menu->addSeparator();
 
     act = menu->addAction(i18n("Configure..."));
     act->setData(QVariant(QString()));
     connect(act, &QAction::triggered, this, &Widget::aggregationSelected);
 }
 
 void Widget::aggregationSelected(bool)
 {
     auto act = qobject_cast<QAction *>(sender());
     if (!act) {
         return;
     }
 
     QVariant v = act->data();
     QString id = v.toString();
 
     if (id.isEmpty()) {
         auto dialog = new Utils::ConfigureAggregationsDialog(window());
         dialog->selectAggregation(d->mLastAggregationId);
         dialog->show();
         return;
     }
 
     if (!d->mStorageModel) {
         return; // nuthin to do
     }
 
     const Aggregation *opt = Manager::instance()->aggregation(id);
 
     delete d->mAggregation;
     d->mAggregation = new Aggregation(*opt);
 
     d->mView->setAggregation(d->mAggregation);
 
     d->mLastAggregationId = opt->id();
 
     // mStorageUsesPrivateAggregation = false;
 
     Manager::instance()->saveAggregationForStorageModel(d->mStorageModel, opt->id(), d->mStorageUsesPrivateAggregation);
 
     // The sort order might not be valid anymore for this aggregation
     d->checkSortOrder(d->mStorageModel);
 
     d->mView->reload();
 }
 
 void Widget::sortOrderMenuAboutToShow()
 {
     if (!d->mAggregation) {
         return;
     }
 
     auto menu = qobject_cast<QMenu *>(sender());
     if (!menu) {
         return;
     }
     sortOrderMenuAboutToShow(menu);
 }
 
 void Widget::sortOrderMenuAboutToShow(QMenu *menu)
 {
     menu->clear();
 
     menu->addSection(i18n("Message Sort Order"));
 
     QActionGroup *grp;
     QAction *act;
     QList<QPair<QString, int>> options;
 
     grp = new QActionGroup(menu);
 
     options = SortOrder::enumerateMessageSortingOptions(d->mAggregation->threading());
     for (const auto &opt : std::as_const(options)) {
         act = menu->addAction(opt.first);
         act->setCheckable(true);
         grp->addAction(act);
         act->setChecked(d->mSortOrder.messageSorting() == opt.second);
         act->setData(QVariant(opt.second));
     }
 
     connect(grp, &QActionGroup::triggered, this, &Widget::messageSortingSelected);
 
     options = SortOrder::enumerateMessageSortDirectionOptions(d->mSortOrder.messageSorting());
 
     if (options.size() >= 2) {
         menu->addSection(i18n("Message Sort Direction"));
 
         grp = new QActionGroup(menu);
         for (const auto &opt : std::as_const(options)) {
             act = menu->addAction(opt.first);
             act->setCheckable(true);
             grp->addAction(act);
             act->setChecked(d->mSortOrder.messageSortDirection() == opt.second);
             act->setData(QVariant(opt.second));
         }
 
         connect(grp, &QActionGroup::triggered, this, &Widget::messageSortDirectionSelected);
     }
 
     options = SortOrder::enumerateGroupSortingOptions(d->mAggregation->grouping());
 
     if (options.size() >= 2) {
         menu->addSection(i18n("Group Sort Order"));
 
         grp = new QActionGroup(menu);
         for (const auto &opt : std::as_const(options)) {
             act = menu->addAction(opt.first);
             act->setCheckable(true);
             grp->addAction(act);
             act->setChecked(d->mSortOrder.groupSorting() == opt.second);
             act->setData(QVariant(opt.second));
         }
 
         connect(grp, &QActionGroup::triggered, this, &Widget::groupSortingSelected);
     }
 
     options = SortOrder::enumerateGroupSortDirectionOptions(d->mAggregation->grouping(), d->mSortOrder.groupSorting());
 
     if (options.size() >= 2) {
         menu->addSection(i18n("Group Sort Direction"));
 
         grp = new QActionGroup(menu);
         for (const auto &opt : std::as_const(options)) {
             act = menu->addAction(opt.first);
             act->setCheckable(true);
             grp->addAction(act);
             act->setChecked(d->mSortOrder.groupSortDirection() == opt.second);
             act->setData(QVariant(opt.second));
         }
 
         connect(grp, &QActionGroup::triggered, this, &Widget::groupSortDirectionSelected);
     }
 
     menu->addSeparator();
     act = menu->addAction(i18n("Folder Always Uses This Sort Order"));
     act->setCheckable(true);
     act->setChecked(d->mStorageUsesPrivateSortOrder);
     connect(act, &QAction::triggered, this, &Widget::setPrivateSortOrderForStorage);
 }
 
 void Widget::WidgetPrivate::switchMessageSorting(SortOrder::MessageSorting messageSorting, SortOrder::SortDirection sortDirection, int logicalHeaderColumnIndex)
 {
     mSortOrder.setMessageSorting(messageSorting);
     mSortOrder.setMessageSortDirection(sortDirection);
 
     // If the logicalHeaderColumnIndex was specified then we already know which
     // column we should set the sort indicator to. If it wasn't specified (it's -1)
     // then we need to find it out in the theme.
 
     if (logicalHeaderColumnIndex == -1) {
         // try to find the specified message sorting in the theme columns
         const auto columns = mTheme->columns();
         int idx = 0;
 
         // First try with a well defined message sorting.
 
         for (const auto column : std::as_const(columns)) {
             if (!mView->header()->isSectionHidden(idx)) {
                 if (column->messageSorting() == messageSorting) {
                     // found a visible column with this message sorting
                     logicalHeaderColumnIndex = idx;
                     break;
                 }
             }
             ++idx;
         }
 
         // if still not found, try again with a wider range
         if (logicalHeaderColumnIndex == -1) {
             idx = 0;
             for (const auto column : std::as_const(columns)) {
                 if (!mView->header()->isSectionHidden(idx)) {
                     if (((column->messageSorting() == SortOrder::SortMessagesBySenderOrReceiver)
                          || (column->messageSorting() == SortOrder::SortMessagesByReceiver) || (column->messageSorting() == SortOrder::SortMessagesBySender))
                         && ((messageSorting == SortOrder::SortMessagesBySenderOrReceiver) || (messageSorting == SortOrder::SortMessagesByReceiver)
                             || (messageSorting == SortOrder::SortMessagesBySender))) {
                         // found a visible column with this message sorting
                         logicalHeaderColumnIndex = idx;
                         break;
                     }
                 }
                 ++idx;
             }
         }
     }
 
     if (logicalHeaderColumnIndex == -1) {
         // not found: either not a column-based sorting or the related column is hidden
         mView->header()->setSortIndicatorShown(false);
         return;
     }
 
     mView->header()->setSortIndicatorShown(true);
 
     if (sortDirection == SortOrder::Ascending) {
         mView->header()->setSortIndicator(logicalHeaderColumnIndex, Qt::AscendingOrder);
     } else {
         mView->header()->setSortIndicator(logicalHeaderColumnIndex, Qt::DescendingOrder);
     }
 }
 
 void Widget::messageSortingSelected(QAction *action)
 {
     if (!d->mAggregation) {
         return;
     }
     if (!action) {
         return;
     }
 
     if (!d->mStorageModel) {
         return;
     }
 
     bool ok;
     auto ord = static_cast<SortOrder::MessageSorting>(action->data().toInt(&ok));
 
     if (!ok) {
         return;
     }
 
     d->switchMessageSorting(ord, d->mSortOrder.messageSortDirection(), -1);
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 
     d->mView->reload();
 }
 
 void Widget::messageSortDirectionSelected(QAction *action)
 {
     if (!d->mAggregation) {
         return;
     }
     if (!action) {
         return;
     }
     if (!d->mStorageModel) {
         return;
     }
 
     bool ok;
     auto ord = static_cast<SortOrder::SortDirection>(action->data().toInt(&ok));
 
     if (!ok) {
         return;
     }
 
     d->switchMessageSorting(d->mSortOrder.messageSorting(), ord, -1);
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 
     d->mView->reload();
 }
 
 void Widget::groupSortingSelected(QAction *action)
 {
     if (!d->mAggregation) {
         return;
     }
     if (!action) {
         return;
     }
 
     if (!d->mStorageModel) {
         return;
     }
 
     bool ok;
     auto ord = static_cast<SortOrder::GroupSorting>(action->data().toInt(&ok));
 
     if (!ok) {
         return;
     }
 
     d->mSortOrder.setGroupSorting(ord);
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 
     d->mView->reload();
 }
 
 void Widget::groupSortDirectionSelected(QAction *action)
 {
     if (!d->mAggregation) {
         return;
     }
     if (!action) {
         return;
     }
     if (!d->mStorageModel) {
         return;
     }
 
     bool ok;
     auto ord = static_cast<SortOrder::SortDirection>(action->data().toInt(&ok));
 
     if (!ok) {
         return;
     }
 
     d->mSortOrder.setGroupSortDirection(ord);
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 
     d->mView->reload();
 }
 
 void Widget::setFilter(Filter *filter)
 {
     resetFilter();
     d->mFilter = filter;
     d->mView->model()->setFilter(d->mFilter);
 }
 
 void Widget::resetFilter()
 {
     delete d->mFilter;
     d->mFilter = nullptr;
     d->mView->model()->setFilter(nullptr);
     d->quickSearchLine->resetFilter();
     d->quickSearchWarning->animatedHide();
 }
 
 void Widget::slotViewHeaderSectionClicked(int logicalIndex)
 {
     if (!d->mTheme) {
         return;
     }
 
     if (!d->mAggregation) {
         return;
     }
 
     if (logicalIndex >= d->mTheme->columns().count()) {
         return;
     }
 
     if (!d->mStorageModel) {
         return;
     }
 
     auto column = d->mTheme->column(logicalIndex);
     if (!column) {
         return; // should never happen...
     }
 
     if (column->messageSorting() == SortOrder::NoMessageSorting) {
         return; // this is a null op.
     }
 
     if (d->mSortOrder.messageSorting() == column->messageSorting()) {
         // switch sort direction
         if (d->mSortOrder.messageSortDirection() == SortOrder::Ascending) {
             d->switchMessageSorting(d->mSortOrder.messageSorting(), SortOrder::Descending, logicalIndex);
         } else {
             d->switchMessageSorting(d->mSortOrder.messageSorting(), SortOrder::Ascending, logicalIndex);
         }
     } else {
         // keep sort direction but switch sort order
         d->switchMessageSorting(column->messageSorting(), d->mSortOrder.messageSortDirection(), logicalIndex);
     }
     Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
 
     d->mView->reload();
 }
 
 void Widget::themesChanged()
 {
     d->setDefaultThemeForStorageModel(d->mStorageModel);
 
     d->mView->reload();
 }
 
 void Widget::aggregationsChanged()
 {
     d->setDefaultAggregationForStorageModel(d->mStorageModel);
     d->checkSortOrder(d->mStorageModel);
 
     d->mView->reload();
 }
 
 void Widget::fillMessageTagCombo()
 {
     // nothing here: must be overridden in derived classes
     setCurrentStatusFilterItem();
 }
 
 void Widget::tagIdSelected(const QVariant &data)
 {
     const QString tagId = data.toString();
 
     if (tagId.isEmpty()) {
         if (d->mFilter) {
             if (d->mFilter->isEmpty()) {
                 resetFilter();
                 return;
             }
         }
     } else {
         if (!d->mFilter) {
             d->mFilter = new Filter();
         }
         d->mFilter->setTagId(tagId);
     }
 
     d->mView->model()->setFilter(d->mFilter);
 }
 
 void Widget::setLockTab(bool lock)
 {
     d->mLockTab = lock;
     if (lock) {
         d->tabLockedWarning->animatedShow();
     } else {
         d->tabLockedWarning->animatedHide();
     }
 }
 
 bool Widget::isLocked() const
 {
     return d->mLockTab;
 }
 
 void Widget::statusSelected(int index)
 {
     if (index == 0) {
         resetFilter();
         return;
     }
     tagIdSelected(d->quickSearchLine->tagFilterComboBox()->itemData(index));
     d->mView->model()->setFilter(d->mFilter);
 }
 
 void Widget::searchEditTextEdited()
 {
     // This slot is called whenever the user edits the search QLineEdit.
     // Since the user is likely to type more than one character
     // so we start the real search after a short delay in order to catch
     // multiple textEdited() signals.
 
     if (!d->mSearchTimer) {
         d->mSearchTimer = new QTimer(this);
         connect(d->mSearchTimer, &QTimer::timeout, this, &Widget::searchTimerFired);
     } else {
         d->mSearchTimer->stop(); // eventually
     }
 
     d->mSearchTimer->setSingleShot(true);
     d->mSearchTimer->start(1s);
 }
 
 void Widget::slotStatusButtonsClicked()
 {
     // We also arbitrarily set tagId to an empty string, though we *could* allow filtering
     // by status AND tag...
     if (d->mFilter) {
         d->mFilter->setTagId(QString());
     }
 
     auto lst = d->quickSearchLine->status();
     if (lst.isEmpty()) {
         if (d->mFilter) {
             d->mFilter->setStatus(lst);
             if (d->mFilter->isEmpty()) {
                 qCDebug(MESSAGELIST_LOG) << " RESET FILTER";
                 resetFilter();
                 return;
             }
         }
     } else {
         // don't have this status bit
         if (!d->mFilter) {
             d->mFilter = new Filter();
         }
         d->mFilter->setStatus(lst);
     }
 
     d->mView->model()->setFilter(d->mFilter);
 }
 
 void Widget::searchTimerFired()
 {
     // A search is pending.
 
     if (d->mSearchTimer) {
         d->mSearchTimer->stop();
     }
 
     if (!d->mFilter) {
         d->mFilter = new Filter();
     }
 
     const QString text = d->quickSearchLine->searchEdit()->text();
 
     if (!text.isEmpty()) {
         d->quickSearchLine->addCompletionItem(text);
     }
 
     d->mFilter->setCurrentFolder(d->mCurrentFolder);
     d->mFilter->setSearchString(text, d->quickSearchLine->searchOptions());
     d->quickSearchWarning->setSearchText(text);
     if (d->mFilter->isEmpty()) {
         resetFilter();
         return;
     }
 
     d->mView->model()->setFilter(d->mFilter);
 }
 
 void Widget::searchEditClearButtonClicked()
 {
     if (!d->mFilter) {
         return;
     }
 
     resetFilter();
 
     d->mView->scrollTo(d->mView->currentIndex(), QAbstractItemView::PositionAtCenter);
 }
 
 void Widget::viewMessageSelected(MessageItem *)
 {
 }
 
 void Widget::viewMessageActivated(MessageItem *)
 {
 }
 
 void Widget::viewSelectionChanged()
 {
 }
 
 void Widget::viewMessageListContextPopupRequest(const QList<MessageItem *> &, const QPoint &)
 {
 }
 
 void Widget::viewGroupHeaderContextPopupRequest(GroupHeaderItem *, const QPoint &)
 {
 }
 
 void Widget::viewDragEnterEvent(QDragEnterEvent *)
 {
 }
 
 void Widget::viewDragMoveEvent(QDragMoveEvent *)
 {
 }
 
 void Widget::viewDropEvent(QDropEvent *)
 {
 }
 
 void Widget::viewStartDragRequest()
 {
 }
 
 void Widget::viewMessageStatusChangeRequest(MessageItem *msg, Akonadi::MessageStatus set, Akonadi::MessageStatus clear)
 {
     Q_UNUSED(msg)
     Q_UNUSED(set)
     Q_UNUSED(clear)
 }
 
 void Widget::focusQuickSearch(const QString &selectedText)
 {
     d->quickSearchLine->focusQuickSearch(selectedText);
 }
 
 bool Widget::isThreaded() const
 {
     return d->mView->isThreaded();
 }
 
 bool Widget::selectionEmpty() const
 {
     return d->mView->selectionEmpty();
 }
 
 Akonadi::Collection Widget::currentFolder() const
 {
     return d->mCurrentFolder;
 }
 
 void Widget::setCurrentFolder(const Akonadi::Collection &collection)
 {
     if (!d->mLockTab) {
         d->mCurrentFolder = collection;
         d->searchCollectionIndexingWarning->setCollection(collection);
     }
 }
 
 bool Widget::searchEditHasFocus() const
 {
     return d->quickSearchLine->searchEdit()->hasFocus();
 }
 
 #include "moc_widgetbase.cpp"