diff --git a/src/folder/foldertreewidget.cpp b/src/folder/foldertreewidget.cpp
index 2f47b99..4750b55 100644
--- a/src/folder/foldertreewidget.cpp
+++ b/src/folder/foldertreewidget.cpp
@@ -1,424 +1,425 @@
 /*
 
   Copyright (c) 2009-2017 Montel Laurent <montel@kde.org>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
 
   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "foldertreewidget.h"
 #include "entitycollectionorderproxymodel.h"
 #include "foldertreeview.h"
 #include "foldertreewidgetproxymodel.h"
 #include "kernel/mailkernel.h"
 #include "util/mailutil.h"
 
 #include <PimCommonAkonadi/ImapAclAttribute>
 #include <PimCommon/PimUtil>
 
 #include <AkonadiCore/AttributeFactory>
 #include <AkonadiCore/ChangeRecorder>
 #include <AkonadiCore/Collection>
 #include <AkonadiCore/EntityMimeTypeFilterModel>
 #include <AkonadiCore/EntityTreeModel>
 #include <AkonadiCore/ItemFetchScope>
 #include <AkonadiCore/QuotaColorProxyModel>
 #include <AkonadiCore/StatisticsProxyModel>
 
 #include <AkonadiWidgets/EntityTreeView>
 #include <AkonadiWidgets/ETMViewStateSaver>
 
 #include <KMime/Message>
 
 #include <MessageCore/MessageCoreSettings>
 
 #include <KLocalizedString>
 
 #include <QFontDatabase>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QLabel>
 #include <QPointer>
 #include <QVBoxLayout>
 
 namespace MailCommon {
 class Q_DECL_HIDDEN FolderTreeWidget::FolderTreeWidgetPrivate
 {
 public:
     FolderTreeWidgetPrivate()
         : filterModel(nullptr)
         , folderTreeView(nullptr)
         , quotaModel(nullptr)
         , readableproxy(nullptr)
         , entityOrderProxy(nullptr)
         , filterFolderLineEdit(nullptr)
         , saver(nullptr)
         , label(nullptr)
         , dontKeyFilter(false)
     {
     }
 
     QString filter;
     QString oldFilterStr;
     Akonadi::StatisticsProxyModel *filterModel = nullptr;
     FolderTreeView *folderTreeView = nullptr;
     Akonadi::QuotaColorProxyModel *quotaModel = nullptr;
     FolderTreeWidgetProxyModel *readableproxy = nullptr;
     EntityCollectionOrderProxyModel *entityOrderProxy = nullptr;
     QLineEdit *filterFolderLineEdit = nullptr;
     QPointer<Akonadi::ETMViewStateSaver> saver;
     QStringList expandedItems;
     QString currentItem;
     QLabel *label = nullptr;
     bool dontKeyFilter = false;
 };
 
 FolderTreeWidget::FolderTreeWidget(
     QWidget *parent, KXMLGUIClient *xmlGuiClient, FolderTreeWidget::TreeViewOptions options, FolderTreeWidgetProxyModel::FolderTreeWidgetProxyModelOptions optReadableProxy)
     : QWidget(parent)
     , d(new FolderTreeWidgetPrivate())
 {
     Akonadi::AttributeFactory::registerAttribute<PimCommon::ImapAclAttribute>();
 
     d->folderTreeView = new FolderTreeView(xmlGuiClient, this, options & ShowUnreadCount);
     d->folderTreeView->showStatisticAnimation(options & ShowCollectionStatisticAnimation);
 
     connect(d->folderTreeView, &FolderTreeView::manualSortingChanged, this, &FolderTreeWidget::slotManualSortingChanged);
 
     QVBoxLayout *lay = new QVBoxLayout(this);
     lay->setMargin(0);
 
     d->label = new QLabel(i18n("You can start typing to filter the list of folders."), this);
     lay->addWidget(d->label);
 
     d->filterFolderLineEdit = new QLineEdit(this);
 
     d->filterFolderLineEdit->setClearButtonEnabled(true);
     d->filterFolderLineEdit->setPlaceholderText(
         i18nc("@info Displayed grayed-out inside the textbox, verb to search",
               "Search"));
     lay->addWidget(d->filterFolderLineEdit);
 
     // ... with statistics...
     d->quotaModel = new Akonadi::QuotaColorProxyModel(this);
     d->quotaModel->setSourceModel(KernelIf->collectionModel());
 
     d->filterModel = new Akonadi::StatisticsProxyModel(this);
     d->filterModel->setSourceModel(d->quotaModel);
 
     d->readableproxy = new FolderTreeWidgetProxyModel(this, optReadableProxy);
     d->readableproxy->setSourceModel(d->filterModel);
     d->readableproxy->addContentMimeTypeInclusionFilter(KMime::Message::mimeType());
 
     connect(d->folderTreeView, &FolderTreeView::changeTooltipsPolicy, this, &FolderTreeWidget::slotChangeTooltipsPolicy);
 
     d->folderTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
     d->folderTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
     d->folderTreeView->installEventFilter(this);
 
     //Order proxy
     d->entityOrderProxy = new EntityCollectionOrderProxyModel(this);
     d->entityOrderProxy->setSourceModel(d->readableproxy);
+    d->entityOrderProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
     KConfigGroup grp(KernelIf->config(), "CollectionTreeOrder");
     d->entityOrderProxy->setOrderConfig(grp);
     d->folderTreeView->setModel(d->entityOrderProxy);
 
     if (options & UseDistinctSelectionModel) {
         d->folderTreeView->setSelectionModel(new QItemSelectionModel(d->entityOrderProxy, this));
     }
 
     lay->addWidget(d->folderTreeView);
 
     d->dontKeyFilter = (options & DontKeyFilter);
 
     if ((options & UseLineEditForFiltering)) {
         connect(d->filterFolderLineEdit, &QLineEdit::textChanged, this, &FolderTreeWidget::slotFilterFixedString);
         d->label->hide();
     } else {
         d->filterFolderLineEdit->hide();
     }
 }
 
 FolderTreeWidget::~FolderTreeWidget()
 {
     delete d;
 }
 
 void FolderTreeWidget::slotFilterFixedString(const QString &text)
 {
     delete d->saver;
     if (d->oldFilterStr.isEmpty()) {
         //Save it.
         Akonadi::ETMViewStateSaver saver;
         saver.setView(folderTreeView());
         d->expandedItems = saver.expansionKeys();
         d->currentItem = saver.currentIndexKey();
     } else if (text.isEmpty()) {
         d->saver = new Akonadi::ETMViewStateSaver;
         d->saver->setView(folderTreeView());
         QString currentIndex = d->saver->currentIndexKey();
         if (d->saver->selectionKeys().isEmpty()) {
             currentIndex = d->currentItem;
         } else if (!currentIndex.isEmpty()) {
             d->expandedItems << currentIndex;
         }
         d->saver->restoreExpanded(d->expandedItems);
         d->saver->restoreCurrentItem(currentIndex);
     } else {
         d->folderTreeView->expandAll();
     }
     d->oldFilterStr = text;
-    d->readableproxy->setFilterFolder(text);
+    d->entityOrderProxy->setFilterWildcard(text);
 }
 
 void FolderTreeWidget::disableContextMenuAndExtraColumn()
 {
     d->folderTreeView->disableContextMenuAndExtraColumn();
 }
 
 void FolderTreeWidget::selectCollectionFolder(const Akonadi::Collection &collection)
 {
     const QModelIndex index
         = Akonadi::EntityTreeModel::modelIndexForCollection(d->folderTreeView->model(), collection);
 
     d->folderTreeView->setCurrentIndex(index);
     d->folderTreeView->setExpanded(index, true);
     d->folderTreeView->scrollTo(index);
 }
 
 void FolderTreeWidget::setSelectionMode(QAbstractItemView::SelectionMode mode)
 {
     d->folderTreeView->setSelectionMode(mode);
 }
 
 QAbstractItemView::SelectionMode FolderTreeWidget::selectionMode() const
 {
     return d->folderTreeView->selectionMode();
 }
 
 QItemSelectionModel *FolderTreeWidget::selectionModel() const
 {
     return d->folderTreeView->selectionModel();
 }
 
 QModelIndex FolderTreeWidget::currentIndex() const
 {
     return d->folderTreeView->currentIndex();
 }
 
 Akonadi::Collection FolderTreeWidget::selectedCollection() const
 {
     if (d->folderTreeView->selectionMode() == QAbstractItemView::SingleSelection) {
         Akonadi::Collection::List lstCollection = selectedCollections();
         if (lstCollection.isEmpty()) {
             return Akonadi::Collection();
         } else {
             return lstCollection.at(0);
         }
     }
 
     return Akonadi::Collection();
 }
 
 Akonadi::Collection::List FolderTreeWidget::selectedCollections() const
 {
     Akonadi::Collection::List collections;
     const QItemSelectionModel *selectionModel = d->folderTreeView->selectionModel();
     const QModelIndexList selectedIndexes = selectionModel->selectedIndexes();
     for (const QModelIndex &index : selectedIndexes) {
         if (index.isValid()) {
             const Akonadi::Collection collection
                 = index.model()->data(
                 index, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
             if (collection.isValid()) {
                 collections.append(collection);
             }
         }
     }
 
     return collections;
 }
 
 FolderTreeView *FolderTreeWidget::folderTreeView() const
 {
     return d->folderTreeView;
 }
 
 void FolderTreeWidget::slotGeneralFontChanged()
 {
     // Custom/System font support
     if (MessageCore::MessageCoreSettings::self()->useDefaultFonts()) {
         setFont(QFontDatabase::systemFont(QFontDatabase::GeneralFont));
     }
 }
 
 void FolderTreeWidget::slotGeneralPaletteChanged()
 {
     d->readableproxy->updatePalette();
     d->folderTreeView->updatePalette();
 }
 
 void FolderTreeWidget::readConfig()
 {
     setFont(QFontDatabase::systemFont(QFontDatabase::GeneralFont));
 
     d->folderTreeView->readConfig();
     d->folderTreeView->setDropActionMenuEnabled(SettingsIf->showPopupAfterDnD());
     d->readableproxy->readConfig();
 
     KConfigGroup readerConfig(KernelIf->config(), "AccountOrder");
     QStringList listOrder;
     if (readerConfig.readEntry("EnableAccountOrder", true)) {
         listOrder = readerConfig.readEntry("order", QStringList());
     }
     d->entityOrderProxy->setTopLevelOrder(listOrder);
 
     readQuotaConfig();
 }
 
 void FolderTreeWidget::restoreHeaderState(const QByteArray &data)
 {
     d->folderTreeView->restoreHeaderState(data);
 }
 
 void FolderTreeWidget::slotChangeTooltipsPolicy(FolderTreeWidget::ToolTipDisplayPolicy policy)
 {
     changeToolTipsPolicyConfig(policy);
 }
 
 void FolderTreeWidget::changeToolTipsPolicyConfig(ToolTipDisplayPolicy policy)
 {
     switch (policy) {
     case DisplayAlways:
     case DisplayWhenTextElided: //Need to implement in the future
         d->filterModel->setToolTipEnabled(true);
         break;
     case DisplayNever:
         d->filterModel->setToolTipEnabled(false);
     }
     d->folderTreeView->setTooltipsPolicy(policy);
 }
 
 void FolderTreeWidget::quotaWarningParameters(const QColor &color, qreal threshold)
 {
     d->quotaModel->setWarningThreshold(threshold);
     d->quotaModel->setWarningColor(color);
 }
 
 void FolderTreeWidget::readQuotaConfig()
 {
     QColor quotaColor = MailCommon::Util::defaultQuotaColor();
     qreal threshold = 100;
     if (!MessageCore::MessageCoreSettings::self()->useDefaultColors()) {
         KConfigGroup readerConfig(KernelIf->config(), "Reader");
         quotaColor = readerConfig.readEntry("CloseToQuotaColor", quotaColor);
     }
     threshold = SettingsIf->closeToQuotaThreshold();
     quotaWarningParameters(quotaColor, threshold);
 }
 
 Akonadi::StatisticsProxyModel *FolderTreeWidget::statisticsProxyModel() const
 {
     return d->filterModel;
 }
 
 FolderTreeWidgetProxyModel *FolderTreeWidget::folderTreeWidgetProxyModel() const
 {
     return d->readableproxy;
 }
 
 EntityCollectionOrderProxyModel *FolderTreeWidget::entityOrderProxy() const
 {
     return d->entityOrderProxy;
 }
 
 QLineEdit *FolderTreeWidget::filterFolderLineEdit() const
 {
     return d->filterFolderLineEdit;
 }
 
 void FolderTreeWidget::applyFilter(const QString &filter)
 {
     d->label->setText(
         filter.isEmpty()
         ? i18n("You can start typing to filter the list of folders.")
         : i18n("Path: (%1)", filter));
 
-    d->readableproxy->setFilterFolder(filter);
+    d->entityOrderProxy->setFilterWildcard(filter);
     d->folderTreeView->expandAll();
     QAbstractItemModel *model = d->folderTreeView->model();
     QModelIndex current = d->folderTreeView->currentIndex();
     QModelIndex start = current.isValid() ? current : model->index(0, 0);
     QModelIndexList list = model->match(start, Qt::DisplayRole, d->filter, 1 /* stop at first hit */,
                                         Qt::MatchContains | Qt::MatchWrap | Qt::MatchRecursive);
     if (!list.isEmpty()) {
         current = list.first();
         d->folderTreeView->setCurrentIndex(current);
         d->folderTreeView->scrollTo(current);
     }
 }
 
 void FolderTreeWidget::clearFilter()
 {
     d->filter.clear();
     applyFilter(d->filter);
     const QModelIndexList lst = d->folderTreeView->selectionModel()->selectedIndexes();
     if (!lst.isEmpty()) {
         d->folderTreeView->scrollTo(lst.first());
     }
 }
 
 void FolderTreeWidget::slotManualSortingChanged(bool active)
 {
     d->entityOrderProxy->setManualSortingActive(active);
     d->folderTreeView->setManualSortingActive(active);
 }
 
 bool FolderTreeWidget::eventFilter(QObject *o, QEvent *e)
 {
     Q_UNUSED(o);
     if (d->dontKeyFilter) {
         return false;
     }
 
     if (e->type() == QEvent::KeyPress) {
         const QKeyEvent *const ke = static_cast<QKeyEvent *>(e);
         switch (ke->key()) {
         case Qt::Key_Backspace:
         {
             const int filterLength(d->filter.length());
             if (filterLength > 0) {
                 d->filter.truncate(filterLength - 1);
             }
             applyFilter(d->filter);
             return false;
         }
         case Qt::Key_Delete:
             d->filter.clear();
             applyFilter(d->filter);
             return false;
         default:
         {
             const QString s = ke->text();
             if (!s.isEmpty() && s.at(0).isPrint()) {
                 d->filter += s;
                 applyFilter(d->filter);
                 return false;
             }
             break;
         }
         }
     }
     return false;
 }
 }
diff --git a/src/folder/foldertreewidgetproxymodel.cpp b/src/folder/foldertreewidgetproxymodel.cpp
index a05d345..c3ba35e 100644
--- a/src/folder/foldertreewidgetproxymodel.cpp
+++ b/src/folder/foldertreewidgetproxymodel.cpp
@@ -1,260 +1,249 @@
 /*
   Copyright (c) 2009-2017 Laurent Montel <montel@kde.org>
 
   This library is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published by
   the Free Software Foundation; either version 2 of the License, or (at your
   option) any later version.
 
   This library is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
   License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.
 */
 
 #include "foldertreewidgetproxymodel.h"
 #include "foldersettings.h"
 #include "kernel/mailkernel.h"
 #include "util/mailutil.h"
 
 #include <MessageCore/MessageCoreSettings>
 
 #include <AgentInstance>
 #include <AgentManager>
 #include <Collection>
 #include <EntityTreeModel>
 #include <MimeTypeChecker>
 
 #include <KColorScheme>
 #include <KLocalizedString>
 
 #include <QPalette>
 
 namespace MailCommon {
 class FolderTreeWidgetProxyModel::Private
 {
 public:
     Private()
         : enableCheck(false)
         , hideVirtualFolder(false)
         , hideSpecificFolder(false)
         , hideOutboxFolder(false)
     {
         const KColorScheme scheme(QPalette::Active, KColorScheme::View);
         brokenAccountColor = scheme.foreground(KColorScheme::NegativeText).color();
     }
 
     QSet<QString> includedMimeTypes;
     Akonadi::MimeTypeChecker checker;
 
     QColor brokenAccountColor;
-    QString filterStr;
     bool enableCheck;
     bool hideVirtualFolder;
     bool hideSpecificFolder;
     bool hideOutboxFolder;
 };
 
 FolderTreeWidgetProxyModel::FolderTreeWidgetProxyModel(QObject *parent, FolderTreeWidgetProxyModelOptions option)
     : Akonadi::EntityRightsFilterModel(parent)
     , d(new Private)
 {
     setDynamicSortFilter(true);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
 
     if (option & HideVirtualFolder) {
         d->hideVirtualFolder = true;
     }
     if (option & HideSpecificFolder) {
         d->hideSpecificFolder = true;
     }
     if (option & HideOutboxFolder) {
         d->hideOutboxFolder = true;
     }
     readConfig();
 }
 
 FolderTreeWidgetProxyModel::~FolderTreeWidgetProxyModel()
 {
     delete d;
 }
 
 void FolderTreeWidgetProxyModel::readConfig()
 {
     invalidate();
 }
 
 Qt::ItemFlags FolderTreeWidgetProxyModel::flags(const QModelIndex &index) const
 {
     if (d->enableCheck) {
         const QModelIndex sourceIndex = mapToSource(index);
         const QModelIndex rowIndex = sourceIndex.sibling(sourceIndex.row(), 0);
         const Akonadi::Collection collection = sourceModel()->data(rowIndex, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
         if (!MailCommon::Util::isVirtualCollection(collection)) {
             const Akonadi::AgentInstance instance = Akonadi::AgentManager::self()->instance(collection.resource());
             if (instance.status() == Akonadi::AgentInstance::Broken) {
                 return KRecursiveFilterProxyModel::flags(sourceIndex) & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
             }
         }
         return Akonadi::EntityRightsFilterModel::flags(index);
     }
     return QSortFilterProxyModel::flags(index);
 }
 
 void FolderTreeWidgetProxyModel::setEnabledCheck(bool enable)
 {
     if (d->enableCheck == enable) {
         return;
     }
 
     d->enableCheck = enable;
     if (enable) {
         setAccessRights(Akonadi::Collection::CanCreateItem | Akonadi::Collection::CanCreateCollection);
     }
 }
 
 bool FolderTreeWidgetProxyModel::enabledCheck() const
 {
     return d->enableCheck;
 }
 
 void FolderTreeWidgetProxyModel::setHideVirtualFolder(bool exclude)
 {
     if (d->hideVirtualFolder != exclude) {
         d->hideVirtualFolder = exclude;
         invalidate();
     }
 }
 
 bool FolderTreeWidgetProxyModel::hideVirtualFolder() const
 {
     return d->hideVirtualFolder;
 }
 
 void FolderTreeWidgetProxyModel::setHideSpecificFolder(bool hide)
 {
     if (d->hideSpecificFolder != hide) {
         d->hideSpecificFolder = hide;
         invalidate();
     }
 }
 
 bool FolderTreeWidgetProxyModel::hideSpecificFolder() const
 {
     return d->hideSpecificFolder;
 }
 
 void FolderTreeWidgetProxyModel::setHideOutboxFolder(bool hide)
 {
     if (d->hideOutboxFolder != hide) {
         d->hideOutboxFolder = hide;
         invalidate();
     }
 }
 
 bool FolderTreeWidgetProxyModel::hideOutboxFolder() const
 {
     return d->hideOutboxFolder;
 }
 
 bool FolderTreeWidgetProxyModel::acceptRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     const QModelIndex modelIndex = sourceModel()->index(sourceRow, 0, sourceParent);
 
     const Akonadi::Collection collection
         = sourceModel()->data(
         modelIndex, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
     if (!d->checker.isWantedCollection(collection)) {
         return false;
     }
 
     if (d->hideVirtualFolder) {
         if (Util::isVirtualCollection(collection)) {
             return false;
         }
     }
 
     if (d->hideSpecificFolder) {
         const QSharedPointer<FolderSettings> col
             = FolderSettings::forCollection(collection, false);
         if (col && col->hideInSelectionDialog()) {
             return false;
         }
     }
 
     if (d->hideOutboxFolder) {
         if (collection == Kernel::self()->outboxCollectionFolder()) {
             return false;
         }
     }
 
-    if (d->filterStr.isEmpty()) {
-        return Akonadi::EntityRightsFilterModel::acceptRow(sourceRow, sourceParent);
-    }
-
     return KRecursiveFilterProxyModel::acceptRow(sourceRow, sourceParent);
 }
 
-void FolderTreeWidgetProxyModel::setFilterFolder(const QString &filter)
-{
-    d->filterStr = filter;
-    setFilterWildcard(filter);
-}
-
 QVariant FolderTreeWidgetProxyModel::data(const QModelIndex &index, int role) const
 {
     if (role == Qt::TextColorRole) {
         const QModelIndex sourceIndex = mapToSource(index);
         const QModelIndex rowIndex = sourceIndex.sibling(sourceIndex.row(), 0);
         const Akonadi::Collection collection
             = sourceModel()->data(
             rowIndex, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
 
         if (!MailCommon::Util::isVirtualCollection(collection)) {
             const Akonadi::AgentInstance instance
                 = Akonadi::AgentManager::self()->instance(collection.resource());
 
             if (instance.status() == Akonadi::AgentInstance::Broken) {
                 return d->brokenAccountColor;
             }
         }
     } else if (role == Qt::DisplayRole) {
         const QModelIndex sourceIndex = mapToSource(index);
         const QModelIndex rowIndex = sourceIndex.sibling(sourceIndex.row(), 0);
         const Akonadi::Collection collection
             = sourceModel()->data(
             rowIndex, Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
         if (!MailCommon::Util::isVirtualCollection(collection)) {
             const Akonadi::AgentInstance instance
                 = Akonadi::AgentManager::self()->instance(collection.resource());
             if (collection.parentCollection() == Akonadi::Collection::root()) {
                 if (!instance.isOnline()) {
                     return i18n("%1 (Offline)", Akonadi::EntityRightsFilterModel::data(index, role).toString());
                 }
             }
         }
     }
     return Akonadi::EntityRightsFilterModel::data(index, role);
 }
 
 void FolderTreeWidgetProxyModel::updatePalette()
 {
     if (MessageCore::MessageCoreSettings::self()->useDefaultColors()) {
         KColorScheme scheme(QPalette::Active, KColorScheme::View);
         d->brokenAccountColor = scheme.foreground(KColorScheme::NegativeText).color();
         invalidate();
     }
 }
 
 void FolderTreeWidgetProxyModel::addContentMimeTypeInclusionFilter(const QString &mimeType)
 {
     d->includedMimeTypes << mimeType;
     d->checker.setWantedMimeTypes(d->includedMimeTypes.toList());
     invalidateFilter();
 }
 }
diff --git a/src/folder/foldertreewidgetproxymodel.h b/src/folder/foldertreewidgetproxymodel.h
index 84501f6..8e1cfa1 100644
--- a/src/folder/foldertreewidgetproxymodel.h
+++ b/src/folder/foldertreewidgetproxymodel.h
@@ -1,76 +1,75 @@
 /*
   Copyright (c) 2009-2015 Laurent Montel <montel@kde.org>
 
   This library is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published by
   the Free Software Foundation; either version 2 of the License, or (at your
   option) any later version.
 
   This library is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
   License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.
 */
 
 #ifndef MAILCOMMON_FOLDERTREEWIDGETPROXYMODEL_H
 #define MAILCOMMON_FOLDERTREEWIDGETPROXYMODEL_H
 
 #include <Collection>
 #include <EntityRightsFilterModel>
 
 namespace MailCommon {
 class FolderTreeWidgetProxyModel : public Akonadi::EntityRightsFilterModel
 {
     Q_OBJECT
 
 public:
     enum FolderTreeWidgetProxyModelOption {
         None = 0,
         HideVirtualFolder = 1,
         HideSpecificFolder = 2,
         HideOutboxFolder = 4
     };
     Q_DECLARE_FLAGS(FolderTreeWidgetProxyModelOptions, FolderTreeWidgetProxyModelOption)
 
     explicit FolderTreeWidgetProxyModel(
         QObject *parent = nullptr, FolderTreeWidgetProxyModelOptions = FolderTreeWidgetProxyModel::None);
 
     virtual ~FolderTreeWidgetProxyModel();
 
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
     void setEnabledCheck(bool enable);
     bool enabledCheck() const;
 
     void setHideVirtualFolder(bool exclude);
     bool hideVirtualFolder() const;
 
     void setHideSpecificFolder(bool hide);
     bool hideSpecificFolder() const;
 
     void setHideOutboxFolder(bool hide);
     bool hideOutboxFolder() const;
-    void setFilterFolder(const QString &filter);
 
     void addContentMimeTypeInclusionFilter(const QString &mimeTypes);
 
     void updatePalette();
     void readConfig();
 
 protected:
     bool acceptRow(int sourceRow, const QModelIndex &sourceParent) const override;
 
 private:
     class Private;
     Private *const d;
 };
 }
 
 #endif