diff --git a/tests/testlib/akonadifakejobs.h b/tests/testlib/akonadifakejobs.h
index 304942eb..f5d9707f 100644
--- a/tests/testlib/akonadifakejobs.h
+++ b/tests/testlib/akonadifakejobs.h
@@ -1,103 +1,103 @@
 /* This file is part of Zanshin
 
    Copyright 2014 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    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.
 */
 
 #ifndef TESTLIB_AKONADIFAKEJOBS_H
 #define TESTLIB_AKONADIFAKEJOBS_H
 
 #include "fakejob.h"
 #include "akonadi/akonadicollectionfetchjobinterface.h"
 #include "akonadi/akonadicollectionsearchjobinterface.h"
 #include "akonadi/akonadiitemfetchjobinterface.h"
 #include "akonadi/akonaditagfetchjobinterface.h"
 
 namespace Testlib {
 
 // cppcheck seems to get confused by the "using" in this class
 // cppcheck-suppress noConstructor
 class AkonadiFakeCollectionFetchJob : public FakeJob, public Akonadi::CollectionFetchJobInterface
 {
     Q_OBJECT
 public:
     using FakeJob::FakeJob;
 
     void setCollections(const Akonadi::Collection::List &collections);
-    Akonadi::Collection::List collections() const;
+    Akonadi::Collection::List collections() const Q_DECL_OVERRIDE;
 
     QString resource() const;
     void setResource(const QString &resource) Q_DECL_OVERRIDE;
 
     bool filtered() const;
-    void setFiltered(bool filter);
+    void setFiltered(bool filter) Q_DECL_OVERRIDE;
 
 private:
     Akonadi::Collection::List m_collections;
     QString m_resource;
     bool m_filter;
 };
 
 class AkonadiFakeCollectionSearchJob : public FakeJob, public Akonadi::CollectionSearchJobInterface
 {
     Q_OBJECT
 public:
     using FakeJob::FakeJob;
 
     void setCollections(const Akonadi::Collection::List &collections);
-    Akonadi::Collection::List collections() const;
+    Akonadi::Collection::List collections() const Q_DECL_OVERRIDE;
 
 private:
     Akonadi::Collection::List m_collections;
 };
 
 class AkonadiFakeItemFetchJob : public FakeJob, public Akonadi::ItemFetchJobInterface
 {
     Q_OBJECT
 public:
     using FakeJob::FakeJob;
 
     void setItems(const Akonadi::Item::List &items);
-    Akonadi::Item::List items() const;
+    Akonadi::Item::List items() const Q_DECL_OVERRIDE;
 
     Akonadi::Collection collection() const;
     void setCollection(const Akonadi::Collection &collection) Q_DECL_OVERRIDE;
 
 private:
     Akonadi::Item::List m_items;
     Akonadi::Collection m_collection;
 };
 
 class AkonadiFakeTagFetchJob : public FakeJob, public Akonadi::TagFetchJobInterface
 {
     Q_OBJECT
 public:
     using FakeJob::FakeJob;
 
     void setTags(const Akonadi::Tag::List &tags);
-    Akonadi::Tag::List tags() const;
+    Akonadi::Tag::List tags() const Q_DECL_OVERRIDE;
 
 private:
     Akonadi::Tag::List m_tags;
 };
 
 }
 
 #endif // TESTLIB_AKONADIFAKEJOBS_H
diff --git a/tests/units/widgets/applicationcomponentstest.cpp b/tests/units/widgets/applicationcomponentstest.cpp
index a37528d3..70f4be10 100644
--- a/tests/units/widgets/applicationcomponentstest.cpp
+++ b/tests/units/widgets/applicationcomponentstest.cpp
@@ -1,676 +1,676 @@
 /* This file is part of Zanshin
 
    Copyright 2014 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    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 <testlib/qtest_gui_zanshin.h>
 
 #include <QMimeData>
 #include <QStandardItemModel>
 #include <QStringListModel>
 #include <QTreeView>
 #include <QWidgetAction>
 
 #include <algorithm>
 
 #include "utils/mem_fn.h"
 
 #include "domain/note.h"
 #include "domain/task.h"
 
 #include "presentation/artifactfilterproxymodel.h"
 #include "presentation/querytreemodelbase.h"
 
 #include "widgets/applicationcomponents.h"
 #include "widgets/availablepagesview.h"
 #include "widgets/availablesourcesview.h"
 #include "widgets/editorview.h"
 #include "widgets/filterwidget.h"
 #include "widgets/pageview.h"
 #include "widgets/quickselectdialog.h"
 
 
 class CustomModelStub : public QStandardItemModel
 {
     Q_OBJECT
 
     QMimeData *mimeData(const QModelIndexList &indexes) const
     {
         QStringList dataString;
         std::transform(indexes.begin(), indexes.end(),
                        std::back_inserter(dataString),
                        [] (const QModelIndex &index) {
                            return index.data().toString();
                        });
 
         auto data = new QMimeData;
         data->setData(QStringLiteral("application/x-zanshin-object"), "object");
         data->setProperty("objects", QVariant::fromValue(dataString));
 
         return data;
     }
 
     bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &destination)
     {
         Q_UNUSED(action);
 
         Q_ASSERT(row == -1);
         Q_ASSERT(column == -1);
         Q_ASSERT(destination.isValid());
         Q_ASSERT(data->hasFormat(QStringLiteral("application/x-zanshin-object")));
 
         auto dataString = data->property("objects").value<QStringList>();
         Q_ASSERT(!dataString.isEmpty());
 
         droppedItemDataString = dataString;
         dropDestination = destination.data().toString();
 
         return true;
     }
 
 public:
     QStringList droppedItemDataString;
     QString dropDestination;
 };
 
 class ApplicationModelStub : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QObject* currentPage READ currentPage WRITE setCurrentPage)
 public:
     typedef QSharedPointer<ApplicationModelStub> Ptr;
 
     explicit ApplicationModelStub(QObject *parent = Q_NULLPTR)
         : QObject(parent), m_currentPage(Q_NULLPTR) {}
 
     QObject *currentPage()
     {
         return m_currentPage;
     }
 
     void setCurrentPage(QObject *page)
     {
         if (page == m_currentPage)
             return;
 
         m_currentPage = page;
         emit currentPageChanged(m_currentPage);
     }
 
 signals:
     void currentPageChanged(QObject *page);
 
 private:
     QObject *m_currentPage;
 };
 
 class AvailablePagesModelStub : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QAbstractItemModel* pageListModel READ pageListModel)
 public:
     explicit AvailablePagesModelStub(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
         QStandardItem *inbox = new QStandardItem;
         inbox->setData("Inbox", Qt::DisplayRole);
         itemModel.appendRow(inbox);
 
         QStandardItem *project = new QStandardItem;
         project->setData("Project", Qt::DisplayRole);
         itemModel.appendRow(project);
     }
 
     QAbstractItemModel *pageListModel()
     {
         return &itemModel;
     }
 
     Q_SCRIPTABLE QObject *createPageForIndex(const QModelIndex &index)
     {
         auto page = new QObject(this);
         auto model = new QStringListModel(page);
         model->setStringList(QStringList() << QStringLiteral("Items") << QStringLiteral("from") << index.data().toString());
         page->setProperty("centralListModel",
                           QVariant::fromValue<QAbstractItemModel*>(model));
         createdPages << page;
         return page;
     }
 
 public:
     QList<QObject*> createdPages;
     CustomModelStub itemModel;
 };
 
 class PageModelStub : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QAbstractItemModel* centralListModel READ centralListModel)
 public:
     QAbstractItemModel *centralListModel()
     {
         return &itemModel;
     }
 
     template<typename T>
     void addItem(const QString &title)
     {
         auto artifact = T::Ptr::create();
         artifact->setTitle(title);
         addItem(artifact);
     }
 
     void addItem(const Domain::Artifact::Ptr &artifact)
     {
         QStandardItem *item = new QStandardItem;
         item->setData(QVariant::fromValue(artifact), Presentation::QueryTreeModelBase::ObjectRole);
         item->setData(artifact->title(), Qt::DisplayRole);
         itemModel.appendRow(item);
     }
 
     Domain::Artifact::Ptr itemAtRow(int row) const
     {
         return itemModel.index(row, 0).data(Presentation::QueryTreeModelBase::ObjectRole)
                                       .value<Domain::Artifact::Ptr>();
     }
 
     QModelIndexList selectedIndexes() const
     {
         return selectedItems;
     }
 
 public:
     QModelIndexList selectedItems;
     CustomModelStub itemModel;
 };
 
 class EditorModelStub : public QObject
 {
     Q_OBJECT
 public:
     explicit EditorModelStub(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
     }
 
     void setPropertyAndSignal(const QByteArray &name, const QVariant &value)
     {
         if (property(name) == value)
             return;
 
         setProperty(name, value);
         if (name == "text")
             emit textChanged(value.toString());
         else if (name == "title")
             emit titleChanged(value.toString());
         else if (name == "done")
             emit doneChanged(value.toBool());
         else if (name == "startDate")
             emit startDateChanged(value.toDateTime());
         else if (name == "dueDate")
             emit dueDateChanged(value.toDateTime());
         else if (name == "hasTaskProperties")
             emit hasTaskPropertiesChanged(value.toBool());
         else
             qFatal("Unsupported property %s", name.constData());
     }
 
 public slots:
     void setTitle(const QString &title) { setPropertyAndSignal("title", title); }
     void setText(const QString &text) { setPropertyAndSignal("text", text); }
     void setDone(bool done) { setPropertyAndSignal("done", done); }
     void setStartDate(const QDateTime &start) { setPropertyAndSignal("startDate", start); }
     void setDueDate(const QDateTime &due) { setPropertyAndSignal("dueDate", due); }
 
 signals:
     void hasTaskPropertiesChanged(bool hasTaskProperties);
     void textChanged(const QString &text);
     void titleChanged(const QString &title);
     void doneChanged(bool done);
     void startDateChanged(const QDateTime &date);
     void dueDateChanged(const QDateTime &due);
 };
 
 class QuickSelectDialogStub : public Widgets::QuickSelectDialogInterface
 {
 public:
     typedef QSharedPointer<QuickSelectDialogStub> Ptr;
 
     explicit QuickSelectDialogStub()
         : parent(Q_NULLPTR),
           execCount(0),
           itemModel(Q_NULLPTR)
     {
     }
 
-    int exec()
+    int exec() Q_DECL_OVERRIDE
     {
         execCount++;
         return QDialog::Accepted;
     }
 
     void setModel(QAbstractItemModel *model) Q_DECL_OVERRIDE
     {
         itemModel = model;
     }
 
     QPersistentModelIndex selectedIndex() const Q_DECL_OVERRIDE
     {
         return index;
     }
 
     QWidget *parent;
     int execCount;
     QAbstractItemModel *itemModel;
     QPersistentModelIndex index;
 };
 
 class ApplicationComponentsTest : public QObject
 {
     Q_OBJECT
 public:
     explicit ApplicationComponentsTest(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
         qputenv("ZANSHIN_UNIT_TEST_RUN", "1");
     }
 
 private slots:
     void shouldHaveApplicationModel()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         auto model = QObjectPtr::create();
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.model(), model);
     }
 
     void shouldApplyAvailableSourcesModelToAvailableSourcesView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         auto model = QObjectPtr::create();
         QObject availableSources;
         model->setProperty("availableSources", QVariant::fromValue(&availableSources));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.availableSourcesView()->model(), &availableSources);
     }
 
     void shouldApplyAvailableSourcesModelAlsoToCreatedAvailableSourcesView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         // Force creation
         components.availableSourcesView();
 
         auto model = QObjectPtr::create();
         QObject availableSources;
         model->setProperty("availableSources", QVariant::fromValue(&availableSources));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.availableSourcesView()->model(), &availableSources);
     }
 
     void shouldApplyAvailablePagesModelToAvailablePagesView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         auto model = QObjectPtr::create();
 
         QObject availablePages;
         model->setProperty("availablePages", QVariant::fromValue(&availablePages));
 
         QObject availableSources;
         QAbstractItemModel *sourcesModel = new QStandardItemModel(model.data());
         availableSources.setProperty("sourceListModel", QVariant::fromValue(sourcesModel));
         model->setProperty("availableSources", QVariant::fromValue(&availableSources));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.availablePagesView()->model(), &availablePages);
         QCOMPARE(components.availablePagesView()->projectSourcesModel(), sourcesModel);
     }
 
     void shouldApplyAvailablePagesModelAlsoToCreatedAvailablePagesView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         // Force creation
         components.availablePagesView();
 
         auto model = QObjectPtr::create();
         QObject availablePages;
         QAbstractItemModel *sourcesModel = new QStandardItemModel(model.data());
         model->setProperty("dataSourcesModel", QVariant::fromValue(sourcesModel));
         model->setProperty("availablePages", QVariant::fromValue(&availablePages));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.availablePagesView()->model(), &availablePages);
         QCOMPARE(components.availablePagesView()->projectSourcesModel(), sourcesModel);
     }
 
     void shouldApplyCurrentPageModelToPageView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         auto model = QObjectPtr::create();
         QObject currentPage;
         model->setProperty("currentPage", QVariant::fromValue(&currentPage));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.pageView()->model(), &currentPage);
     }
 
     void shouldApplyCurrentPageModelAlsoToCreatedPageView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         // Force creation
         components.pageView();
 
         auto model = QObjectPtr::create();
         QObject currentPage;
         model->setProperty("currentPage", QVariant::fromValue(&currentPage));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.pageView()->model(), &currentPage);
     }
 
     void shouldApplyEditorModelToEditorView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         auto model = QObjectPtr::create();
         QObject *editorModel = new EditorModelStub(model.data());
         model->setProperty("editor", QVariant::fromValue(editorModel));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.editorView()->model(), editorModel);
     }
 
     void shouldApplyEditorModelAltoToCreatedPageView()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         // Force creation
         components.editorView();
 
         auto model = QObjectPtr::create();
         QObject *editorModel = new EditorModelStub(model.data());
         model->setProperty("editor", QVariant::fromValue(editorModel));
 
         // WHEN
         components.setModel(model);
 
         // THEN
         QCOMPARE(components.editorView()->model(), editorModel);
     }
 
     void shouldPropageNullModelsToViews()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
 
         auto model = QObjectPtr::create();
         auto availableSources = new QObject(model.data());
         model->setProperty("availableSources", QVariant::fromValue(availableSources));
         auto availablePages = new QObject(model.data());
         model->setProperty("availablePages", QVariant::fromValue(availablePages));
         auto currentPage = new QObject(model.data());
         model->setProperty("currentPage", QVariant::fromValue(currentPage));
         auto editorModel = new EditorModelStub(model.data());
         model->setProperty("editor", QVariant::fromValue<QObject*>(editorModel));
 
         components.setModel(model);
 
         // WHEN
         components.setModel(QObjectPtr());
         components.availableSourcesView();
         components.availablePagesView();
         components.pageView();
         components.editorView();
 
         // THEN
         QVERIFY(!components.availableSourcesView()->model());
         QVERIFY(!components.availablePagesView()->model());
         QVERIFY(!components.pageView()->model());
         QVERIFY(!components.editorView()->model());
     }
 
     void shouldPropageNullModelsToCreatedViews()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
         components.availableSourcesView();
         components.availablePagesView();
         components.pageView();
         components.editorView();
 
         auto model = QObjectPtr::create();
         auto availableSources = new QObject(model.data());
         model->setProperty("availableSources", QVariant::fromValue(availableSources));
         auto availablePages = new QObject(model.data());
         model->setProperty("availablePages", QVariant::fromValue(availablePages));
         auto currentPage = new QObject(model.data());
         model->setProperty("currentPage", QVariant::fromValue(currentPage));
         auto editorModel = new EditorModelStub(model.data());
         model->setProperty("editor", QVariant::fromValue<QObject*>(editorModel));
 
         components.setModel(model);
 
         // WHEN
         components.setModel(QObjectPtr());
 
         // THEN
         QVERIFY(!components.availableSourcesView()->model());
         QVERIFY(!components.availablePagesView()->model());
         QVERIFY(!components.pageView()->model());
         QVERIFY(!components.editorView()->model());
     }
 
     void shouldApplyAvailablePagesSelectionToApplicationModel()
     {
         // GIVEN
         auto model = ApplicationModelStub::Ptr::create();
 
         AvailablePagesModelStub availablePagesModel;
         model->setProperty("availablePages", QVariant::fromValue<QObject*>(&availablePagesModel));
         model->setProperty("currentPage", QVariant::fromValue<QObject*>(Q_NULLPTR));
 
         QObject editorModel;
         editorModel.setProperty("artifact",
                                 QVariant::fromValue<Domain::Artifact::Ptr>(Domain::Task::Ptr::create()));
         model->setProperty("editor", QVariant::fromValue<QObject*>(&editorModel));
 
         Widgets::ApplicationComponents components;
         components.setModel(model);
 
         Widgets::AvailablePagesView *availablePagesView = components.availablePagesView();
         auto pagesView = availablePagesView->findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
 
         Widgets::PageView *pageView = components.pageView();
         QVERIFY(pageView);
         QVERIFY(!pageView->model());
 
         QModelIndex index = pagesView->model()->index(0, 0);
 
         // WHEN
         pagesView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
 
         // THEN
         QCOMPARE(availablePagesModel.createdPages.size(), 1);
         QCOMPARE(model->property("currentPage").value<QObject*>(),
                  availablePagesModel.createdPages.first());
         QCOMPARE(pageView->model(),
                  availablePagesModel.createdPages.first());
         QVERIFY(editorModel.property("artifact").value<Domain::Artifact::Ptr>().isNull());
     }
 
     void shouldApplyPageViewSelectionToEditorModel()
     {
         // GIVEN
         auto model = QObjectPtr::create();
 
         PageModelStub pageModel;
         pageModel.addItem<Domain::Task>(QStringLiteral("0. First task"));
         pageModel.addItem<Domain::Note>(QStringLiteral("1. A note"));
         pageModel.addItem<Domain::Task>(QStringLiteral("2. Second task"));
         pageModel.addItem<Domain::Note>(QStringLiteral("3. Another note"));
         model->setProperty("currentPage", QVariant::fromValue<QObject*>(&pageModel));
 
         EditorModelStub editorModel;
         model->setProperty("editor", QVariant::fromValue<QObject*>(&editorModel));
 
         Widgets::ApplicationComponents components;
         components.setModel(model);
 
         Widgets::PageView *pageView = components.pageView();
         auto centralView = pageView->findChild<QTreeView*>(QStringLiteral("centralView"));
         QModelIndex index = centralView->model()->index(2, 0);
 
         // WHEN
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
 
         // THEN
         QCOMPARE(editorModel.property("artifact").value<Domain::Artifact::Ptr>(),
                  pageModel.itemAtRow(index.row()));
     }
 
     void shouldHaveDefaultActionsList()
     {
         // GIVEN
         Widgets::ApplicationComponents components;
 
         // WHEN
         auto actions = components.globalActions();
 
         // THEN
 
         // availablePages view
         auto available = components.availablePagesView();
         foreach (const auto &key,  available->globalActions().keys())
             QCOMPARE(actions.value(key), available->globalActions().value(key));
 
         // availableSources view
         auto availableSources = components.availableSourcesView();
         foreach (const auto &key, availableSources->globalActions().keys())
             QCOMPARE(actions.value(key), availableSources->globalActions().value(key));
 
         // page view
         auto page = components.pageView();
         foreach (const auto &key, page->globalActions().keys())
             QCOMPARE(actions.value(key), page->globalActions().value(key));
 
         // application component own action
         auto moveAction = components.findChild<QAction*>(QStringLiteral("moveItemAction"));
         QCOMPARE(actions.value(QStringLiteral("page_view_move")), moveAction);
     }
 
     void shouldMoveItem()
     {
         // GIVEN
         auto model = QObjectPtr::create();
 
         PageModelStub pageModel;
         pageModel.addItem<Domain::Task>(QStringLiteral("0. First task"));
         pageModel.addItem<Domain::Note>(QStringLiteral("1. A note"));
         pageModel.addItem<Domain::Task>(QStringLiteral("2. Second task"));
         pageModel.addItem<Domain::Note>(QStringLiteral("3. Another note"));
         model->setProperty("currentPage", QVariant::fromValue<QObject*>(&pageModel));
 
         AvailablePagesModelStub availablePagesModelStub;
         model->setProperty("availablePages", QVariant::fromValue<QObject*>(&availablePagesModelStub));
 
         QWidget *mainWidget = new QWidget;
         Widgets::ApplicationComponents components(mainWidget);
         components.setModel(model);
 
         auto availablePageView = components.availablePagesView();
         auto availablePagesTreeView = availablePageView->findChild<QTreeView*>(QStringLiteral("pagesView"));
         Q_ASSERT(availablePagesTreeView);
 
         auto dialogStub = QuickSelectDialogStub::Ptr::create();
         dialogStub->index = availablePagesModelStub.pageListModel()->index(0, 0); // inbox selected
         components.setQuickSelectDialogFactory([dialogStub] (QWidget *parent) {
             dialogStub->parent = parent;
             return dialogStub;
         });
 
         auto pageView = components.pageView();
         auto centralView = pageView->findChild<QTreeView*>(QStringLiteral("centralView"));
         QModelIndex index1 = pageModel.itemModel.index(0,0);
         QModelIndex index2 = pageModel.itemModel.index(2,0);
 
         auto filterWidget = pageView->findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         auto displayedModel = filterWidget->proxyModel();
         auto displayedIndex = displayedModel->index(0, 0);
         auto displayedIndex2 = displayedModel->index(2, 0);
 
         auto moveAction = components.findChild<QAction*>(QStringLiteral("moveItemAction"));
 
         // WHEN
         pageModel.selectedItems << index1 << index2;
         centralView->selectionModel()->setCurrentIndex(displayedIndex, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->setCurrentIndex(displayedIndex2, QItemSelectionModel::Select);
 
         moveAction->trigger();
 
         // THEN
         QCOMPARE(dialogStub->execCount, 1);
         QCOMPARE(dialogStub->parent, pageView);
         QCOMPARE(dialogStub->itemModel, availablePagesModelStub.pageListModel());
 
         QCOMPARE(availablePagesModelStub.itemModel.dropDestination, QStringLiteral("Inbox"));
         QCOMPARE(availablePagesModelStub.itemModel.droppedItemDataString.size(), 2);
         QCOMPARE(availablePagesModelStub.itemModel.droppedItemDataString.at(0), index1.data().toString());
         QCOMPARE(availablePagesModelStub.itemModel.droppedItemDataString.at(1), index2.data().toString());
     }
 };
 
 ZANSHIN_TEST_MAIN(ApplicationComponentsTest)
 
 #include "applicationcomponentstest.moc"
diff --git a/tests/units/widgets/availablepagesviewtest.cpp b/tests/units/widgets/availablepagesviewtest.cpp
index 01ad5d0a..b6709aa1 100644
--- a/tests/units/widgets/availablepagesviewtest.cpp
+++ b/tests/units/widgets/availablepagesviewtest.cpp
@@ -1,598 +1,598 @@
 /* This file is part of Zanshin
 
    Copyright 2014 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    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 <testlib/qtest_gui_zanshin.h>
 
 #include <QAbstractItemModel>
 #include <QAction>
 #include <QDebug>
 #include <QHeaderView>
 #include <QStandardItemModel>
 #include <QStringListModel>
 #include <QToolBar>
 #include <QTreeView>
 
 #include "domain/project.h"
 #include "domain/context.h"
 #include "domain/tag.h"
 
 #include "presentation/metatypes.h"
 #include "presentation/querytreemodelbase.h"
 
 #include "widgets/availablepagesview.h"
 #include "widgets/newprojectdialog.h"
 #include "widgets/quickselectdialog.h"
 
 #include "messageboxstub.h"
 
 class NewProjectDialogStub : public Widgets::NewProjectDialogInterface
 {
 public:
     typedef QSharedPointer<NewProjectDialogStub> Ptr;
 
     explicit NewProjectDialogStub()
         : parent(Q_NULLPTR),
           execCount(0),
           sourceModel(Q_NULLPTR),
           source(Domain::DataSource::Ptr::create())
     {
     }
 
-    int exec()
+    int exec() Q_DECL_OVERRIDE
     {
         execCount++;
         return QDialog::Accepted;
     }
 
     void setDataSourcesModel(QAbstractItemModel *model) Q_DECL_OVERRIDE
     {
         sourceModel = model;
     }
 
     QString name() const Q_DECL_OVERRIDE
     {
         return QStringLiteral("name");
     }
 
     Domain::DataSource::Ptr dataSource() const Q_DECL_OVERRIDE
     {
         return source;
     }
 
     QWidget *parent;
     int execCount;
     QAbstractItemModel *sourceModel;
     Domain::DataSource::Ptr source;
 };
 
 class QuickSelectDialogStub : public Widgets::QuickSelectDialogInterface
 {
 public:
     typedef QSharedPointer<QuickSelectDialogStub> Ptr;
 
     explicit QuickSelectDialogStub()
         : parent(Q_NULLPTR),
           execCount(0),
           itemModel(Q_NULLPTR)
     {
     }
 
-    int exec()
+    int exec() Q_DECL_OVERRIDE
     {
         execCount++;
         return QDialog::Accepted;
     }
 
     void setModel(QAbstractItemModel *model) Q_DECL_OVERRIDE
     {
         itemModel = model;
     }
 
     QPersistentModelIndex selectedIndex() const Q_DECL_OVERRIDE
     {
         return index;
     }
 
     QWidget *parent;
     int execCount;
     QAbstractItemModel *itemModel;
     QPersistentModelIndex index;
 };
 
 class AvailablePagesModelStub : public QObject
 {
     Q_OBJECT
 public:
     explicit AvailablePagesModelStub(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
     }
 public slots:
     void addProject(const QString &name, const Domain::DataSource::Ptr &source)
     {
         projectNames << name;
         sources << source;
     }
 
     void addContext(const QString &name)
     {
         contextNames << name;
     }
 
     void addTag(const QString &name)
     {
         tagNames << name;
     }
 
     void removeItem(const QModelIndex &index)
     {
         projectRemoved = index.data().toString();
     }
 
 public Q_SLOTS:
     QObject *createPageForIndex(const QModelIndex &) { return Q_NULLPTR; }
 
 public:
     QStringList projectNames;
     QStringList contextNames;
     QStringList tagNames;
     QList<Domain::DataSource::Ptr> sources;
     QString projectRemoved;
 };
 
 class AvailablePagesViewTest : public QObject
 {
     Q_OBJECT
 private slots:
     void shouldHaveDefaultState()
     {
         Widgets::AvailablePagesView available;
 
         QVERIFY(!available.model());
         QVERIFY(!available.projectSourcesModel());
         QVERIFY(available.defaultProjectSource().isNull());
 
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QVERIFY(pagesView->isVisibleTo(&available));
         QVERIFY(!pagesView->header()->isVisibleTo(&available));
         QCOMPARE(pagesView->dragDropMode(), QTreeView::DropOnly);
 
         auto actionBar = available.findChild<QToolBar*>(QStringLiteral("actionBar"));
         QVERIFY(actionBar);
         QVERIFY(actionBar->isVisibleTo(&available));
 
         auto addProjectAction = available.findChild<QAction*>(QStringLiteral("addProjectAction"));
         QVERIFY(addProjectAction);
         auto addContextAction = available.findChild<QAction*>(QStringLiteral("addContextAction"));
         QVERIFY(addContextAction);
         auto addTagAction = available.findChild<QAction*>(QStringLiteral("addTagAction"));
         QVERIFY(addTagAction);
         auto removeAction = available.findChild<QAction*>(QStringLiteral("removeAction"));
         QVERIFY(removeAction);
         auto goPreviousAction = available.findChild<QAction*>(QStringLiteral("goPreviousAction"));
         QVERIFY(goPreviousAction);
         auto goNextAction = available.findChild<QAction*>(QStringLiteral("goNextAction"));
         QVERIFY(goNextAction);
         auto goToAction = available.findChild<QAction*>(QStringLiteral("goToAction"));
         QVERIFY(goToAction);
 
         auto projectDialogFactory = available.projectDialogFactory();
         QVERIFY(projectDialogFactory(&available).dynamicCast<Widgets::NewProjectDialog>());
 
         auto quickSelectDialogFactory = available.quickSelectDialogFactory();
         QVERIFY(quickSelectDialogFactory(&available).dynamicCast<Widgets::QuickSelectDialog>());
 
         auto actions = available.globalActions();
         QCOMPARE(actions.value(QStringLiteral("pages_project_add")), addProjectAction);
         QCOMPARE(actions.value(QStringLiteral("pages_context_add")), addContextAction);
         QCOMPARE(actions.value(QStringLiteral("pages_tag_add")), addTagAction);
         QCOMPARE(actions.value(QStringLiteral("pages_remove")), removeAction);
         QCOMPARE(actions.value(QStringLiteral("pages_go_previous")), goPreviousAction);
         QCOMPARE(actions.value(QStringLiteral("pages_go_next")), goNextAction);
         QCOMPARE(actions.value(QStringLiteral("pages_go_to")), goToAction);
     }
 
     void shouldShowOnlyAddActionsNeededByTheModel_data()
     {
         QTest::addColumn<bool>("hasProjects");
         QTest::addColumn<bool>("hasContexts");
         QTest::addColumn<bool>("hasTags");
 
         QTest::newRow("!projects !contexts !tags") << false << false << false;
         QTest::newRow("!projects !contexts tags") << false << false << true;
         QTest::newRow("!projects contexts !tags") << false << true << false;
         QTest::newRow("!projects contexts tags") << false << true << true;
         QTest::newRow("projects !contexts !tags") << true << false << false;
         QTest::newRow("projects !contexts tags") << true << false << true;
         QTest::newRow("projects contexts !tags") << true << true << false;
         QTest::newRow("projects contexts tags") << true << true << true;
     }
 
     void shouldShowOnlyAddActionsNeededByTheModel()
     {
         // GIVEN
         QFETCH(bool, hasProjects);
         QFETCH(bool, hasContexts);
         QFETCH(bool, hasTags);
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("hasProjectPages", hasProjects);
         stubPagesModel.setProperty("hasContextPages", hasContexts);
         stubPagesModel.setProperty("hasTagPages", hasTags);
 
         Widgets::AvailablePagesView available;
         auto addProjectAction = available.findChild<QAction*>(QStringLiteral("addProjectAction"));
         QVERIFY(addProjectAction);
         auto addContextAction = available.findChild<QAction*>(QStringLiteral("addContextAction"));
         QVERIFY(addContextAction);
         auto addTagAction = available.findChild<QAction*>(QStringLiteral("addTagAction"));
         QVERIFY(addTagAction);
 
         // WHEN
         available.setModel(&stubPagesModel);
 
         // THEN
         QCOMPARE(addProjectAction->isVisible(), hasProjects);
         QCOMPARE(addContextAction->isVisible(), hasContexts);
         QCOMPARE(addTagAction->isVisible(), hasTags);
     }
 
     void shouldDisplayListFromPageModel()
     {
         // GIVEN
         QStringListModel model(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C") );
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::AvailablePagesView available;
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QVERIFY(!pagesView->model());
 
         // WHEN
         available.setModel(&stubPagesModel);
         QTest::qWait(10);
 
         // THEN
         QCOMPARE(pagesView->model(), &model);
         QCOMPARE(pagesView->selectionModel()->currentIndex(), model.index(0, 0));
     }
 
     void shouldNotCrashWithNullModel()
     {
         // GIVEN
         QStringListModel model(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C") );
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::AvailablePagesView available;
         available.setModel(&stubPagesModel);
         QTest::qWait(10);
 
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QCOMPARE(pagesView->model(), &model);
 
         // WHEN
         available.setModel(Q_NULLPTR);
         QTest::qWait(10);
 
         // THEN
         QVERIFY(!available.isEnabled());
         QVERIFY(!pagesView->model());
     }
 
     void shouldAddNewProjects()
     {
         // GIVEN
         AvailablePagesModelStub model;
         QStringListModel sourceModel;
         auto dialogStub = NewProjectDialogStub::Ptr::create();
 
         auto source = Domain::DataSource::Ptr::create();
 
         Widgets::AvailablePagesView available;
         available.setModel(&model);
         available.setProjectSourcesModel(&sourceModel);
         available.setDefaultProjectSource(source);
         available.setProjectDialogFactory([dialogStub] (QWidget *parent) {
             dialogStub->parent = parent;
             return dialogStub;
         });
 
         auto addProjectAction = available.findChild<QAction*>(QStringLiteral("addProjectAction"));
 
         // WHEN
         addProjectAction->trigger();
 
         // THEN
         QCOMPARE(dialogStub->execCount, 1);
         QCOMPARE(dialogStub->parent, &available);
         QCOMPARE(dialogStub->sourceModel, &sourceModel);
         QCOMPARE(model.projectNames.size(), 1);
         QCOMPARE(model.projectNames.first(), dialogStub->name());
         QCOMPARE(model.sources.size(), 1);
         QCOMPARE(model.sources.first(), dialogStub->dataSource());
         QCOMPARE(available.defaultProjectSource(), dialogStub->dataSource());
     }
 
     void shouldAddNewContexts()
     {
         // GIVEN
         AvailablePagesModelStub model;
         QStringListModel sourceModel;
         auto dialogStub = NewProjectDialogStub::Ptr::create();
 
         auto source = Domain::DataSource::Ptr::create();
 
         auto msgBoxStub = MessageBoxStub::Ptr::create();
         msgBoxStub->setTextInput(QStringLiteral("Foo"));
 
         Widgets::AvailablePagesView available;
         available.setModel(&model);
         available.setProjectSourcesModel(&sourceModel);
         available.setDefaultProjectSource(source);
         available.setMessageBoxInterface(msgBoxStub);
 
         auto addContextAction = available.findChild<QAction*>(QStringLiteral("addContextAction"));
 
         // WHEN
         addContextAction->trigger();
 
         // THEN
         QVERIFY(msgBoxStub->called());
         QCOMPARE(model.contextNames.size(), 1);
         QCOMPARE(model.contextNames.first(), QStringLiteral("Foo"));
     }
 
     void shouldAddNewTags()
     {
         // GIVEN
         AvailablePagesModelStub model;
         QStringListModel sourceModel;
         auto dialogStub = NewProjectDialogStub::Ptr::create();
 
         auto source = Domain::DataSource::Ptr::create();
 
         auto msgBoxStub = MessageBoxStub::Ptr::create();
         msgBoxStub->setTextInput(QStringLiteral("Foo"));
 
         Widgets::AvailablePagesView available;
         available.setModel(&model);
         available.setProjectSourcesModel(&sourceModel);
         available.setDefaultProjectSource(source);
         available.setMessageBoxInterface(msgBoxStub);
 
         auto addTagAction = available.findChild<QAction*>(QStringLiteral("addTagAction"));
 
         // WHEN
         addTagAction->trigger();
 
         // THEN
         QVERIFY(msgBoxStub->called());
         QCOMPARE(model.tagNames.size(), 1);
         QCOMPARE(model.tagNames.first(), QStringLiteral("Foo"));
     }
 
     void shouldRemoveAPage_data()
     {
         QTest::addColumn<QObjectPtr>("object");
         QTest::addColumn<bool>("actionEnabled");
 
         auto project1 = Domain::Project::Ptr::create();
         project1->setName(QStringLiteral("Project 1"));
         QTest::newRow("project") << QObjectPtr(project1) << true;
 
         auto context1 = Domain::Context::Ptr::create();
         context1->setName(QStringLiteral("Context 1"));
         QTest::newRow("context") << QObjectPtr(context1) << true;
 
         auto tag1 = Domain::Tag::Ptr::create();
         tag1->setName(QStringLiteral("Tag 1"));
         QTest::newRow("tag") << QObjectPtr(tag1) << true;
 
         QTest::newRow("non removable") << QObjectPtr::create() << false;
     }
 
     void shouldRemoveAPage()
     {
         QFETCH(QObjectPtr, object);
         QFETCH(bool, actionEnabled);
 
         // GIVEN
         QStringList list;
         list << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C");
         QStandardItemModel model;
         for (int row = 0; row < list.count(); ++row) {
             model.setItem(row, new QStandardItem(list.at(row)));
         }
         QVERIFY(model.setData(model.index(0, 0), QVariant::fromValue(object), Presentation::QueryTreeModelBase::ObjectRole));
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::AvailablePagesView available;
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QVERIFY(!pagesView->model());
 
         available.setModel(&stubPagesModel);
         QTest::qWait(10);
 
         auto removeAction = available.findChild<QAction*>(QStringLiteral("removeAction"));
 
         auto msgbox = MessageBoxStub::Ptr::create();
         available.setMessageBoxInterface(msgbox);
 
         // WHEN
         if (actionEnabled)
             removeAction->trigger();
 
         // THEN
         QCOMPARE(removeAction->isEnabled(), actionEnabled);
         if (actionEnabled) {
             QCOMPARE(stubPagesModel.projectRemoved, list.first());
         }
     }
 
     void shouldGoToPreviousSelectablePage()
     {
         // GIVEN
         QStandardItemModel model;
         model.appendRow(new QStandardItem(QStringLiteral("Inbox")));
         auto projects = new QStandardItem(QStringLiteral("Projects"));
         projects->setFlags(Qt::NoItemFlags);
         model.appendRow(projects);
         projects->appendRow(new QStandardItem(QStringLiteral("Project 1")));
         projects->appendRow(new QStandardItem(QStringLiteral("Project 2")));
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::AvailablePagesView available;
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QVERIFY(!pagesView->model());
 
         available.setModel(&stubPagesModel);
         QTest::qWait(10);
 
         auto goPreviousAction = available.findChild<QAction*>(QStringLiteral("goPreviousAction"));
         pagesView->setCurrentIndex(model.index(1, 0, model.indexFromItem(projects)));
 
         // WHEN
         goPreviousAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(0, 0, model.indexFromItem(projects)));
 
         // WHEN
         goPreviousAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(0, 0));
 
         // WHEN
         goPreviousAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(0, 0));
     }
 
     void shouldGoToNextSelectablePage()
     {
         // GIVEN
         QStandardItemModel model;
         model.appendRow(new QStandardItem(QStringLiteral("Inbox")));
         auto projects = new QStandardItem(QStringLiteral("Projects"));
         projects->setFlags(Qt::NoItemFlags);
         model.appendRow(projects);
         projects->appendRow(new QStandardItem(QStringLiteral("Project 1")));
         projects->appendRow(new QStandardItem(QStringLiteral("Project 2")));
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::AvailablePagesView available;
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QVERIFY(!pagesView->model());
 
         available.setModel(&stubPagesModel);
         QTest::qWait(10);
 
         auto goNextAction = available.findChild<QAction*>(QStringLiteral("goNextAction"));
         pagesView->setCurrentIndex(model.index(0, 0));
 
         // WHEN
         goNextAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(0, 0, model.indexFromItem(projects)));
 
         // WHEN
         goNextAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(1, 0, model.indexFromItem(projects)));
 
         // WHEN
         goNextAction->trigger();
 
         // THEN
         QCOMPARE(pagesView->currentIndex(),
                  model.index(1, 0, model.indexFromItem(projects)));
     }
 
     void shouldGoToUserSelectedIndex()
     {
         // GIVEN
         QStandardItemModel model;
         model.appendRow(new QStandardItem(QStringLiteral("Inbox")));
         auto projects = new QStandardItem(QStringLiteral("Projects"));
         projects->setFlags(Qt::NoItemFlags);
         model.appendRow(projects);
         projects->appendRow(new QStandardItem(QStringLiteral("Project 1")));
         projects->appendRow(new QStandardItem(QStringLiteral("Project 2")));
 
         AvailablePagesModelStub stubPagesModel;
         stubPagesModel.setProperty("pageListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
         auto dialogStub = QuickSelectDialogStub::Ptr::create();
         // Project 2 will be selected
         dialogStub->index = model.index(1, 0, model.index(1, 0));
 
         Widgets::AvailablePagesView available;
         available.setModel(&stubPagesModel);
         available.setQuickSelectDialogFactory([dialogStub] (QWidget *parent) {
             dialogStub->parent = parent;
             return dialogStub;
         });
 
         auto pagesView = available.findChild<QTreeView*>(QStringLiteral("pagesView"));
         QVERIFY(pagesView);
         QCOMPARE(pagesView->model(), &model);
 
         auto goToAction = available.findChild<QAction*>(QStringLiteral("goToAction"));
 
         // WHEN
         goToAction->trigger();
 
         // THEN
         QCOMPARE(dialogStub->execCount, 1);
         QCOMPARE(dialogStub->parent, &available);
         QCOMPARE(dialogStub->itemModel, &model);
         QCOMPARE(QPersistentModelIndex(pagesView->currentIndex()), dialogStub->index);
     }
 };
 
 ZANSHIN_TEST_MAIN(AvailablePagesViewTest)
 
 #include "availablepagesviewtest.moc"