diff --git a/src/akonadi/akonadistorage.cpp b/src/akonadi/akonadistorage.cpp
index 79e02358..4080cf6d 100644
--- a/src/akonadi/akonadistorage.cpp
+++ b/src/akonadi/akonadistorage.cpp
@@ -1,401 +1,407 @@
 /* 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 "akonadistorage.h"
 
 #include <algorithm>
 
 #include <KCalCore/Todo>
 
 #include <AkonadiCore/CollectionCreateJob>
 #include <AkonadiCore/CollectionDeleteJob>
 #include <AkonadiCore/CollectionFetchScope>
 #include <AkonadiCore/CollectionModifyJob>
 #include <AkonadiCore/ItemCreateJob>
 #include <AkonadiCore/ItemDeleteJob>
 #include <AkonadiCore/ItemFetchJob>
 #include <AkonadiCore/ItemFetchScope>
 #include <AkonadiCore/ItemModifyJob>
 #include <AkonadiCore/ItemMoveJob>
 #include <Akonadi/Notes/NoteUtils>
 #include <AkonadiCore/TransactionSequence>
 #include <AkonadiCore/TagCreateJob>
 #include <AkonadiCore/TagDeleteJob>
 #include <AkonadiCore/TagFetchJob>
 #include <AkonadiCore/TagFetchScope>
 #include <AkonadiCore/TagModifyJob>
 #include <AkonadiCore/TagAttribute>
 #include "akonadi/akonadicollectionfetchjobinterface.h"
 #include "akonadi/akonadicollectionsearchjobinterface.h"
 #include "akonadi/akonadiitemfetchjobinterface.h"
 #include "akonadi/akonaditagfetchjobinterface.h"
 #include "akonadi/akonadistoragesettings.h"
 
 using namespace Akonadi;
 
 class CollectionJob : public CollectionFetchJob, public CollectionFetchJobInterface
 {
+    Q_OBJECT
 public:
     CollectionJob(const Collection &collection, Type type = FirstLevel, QObject *parent = Q_NULLPTR)
         : CollectionFetchJob(collection, type, parent),
           m_collection(collection),
           m_type(type)
     {
     }
 
     Collection::List collections() const Q_DECL_OVERRIDE
     {
         auto collections = CollectionFetchJob::collections();
 
         // Memorize them to reconstruct the ancestor chain later
         QMap<Collection::Id, Collection> collectionsMap;
         collectionsMap[m_collection.id()] = m_collection;
         for (auto collection : collections) {
             collectionsMap[collection.id()] = collection;
         }
 
         // Why the hell isn't fetchScope() const and returning a reference???
         auto self = const_cast<CollectionJob*>(this);
         const auto allowedMimeTypes = self->fetchScope().contentMimeTypes().toSet();
 
         if (!allowedMimeTypes.isEmpty()) {
             collections.erase(std::remove_if(collections.begin(), collections.end(),
                                              [allowedMimeTypes] (const Collection &collection) {
                                                 auto mimeTypes = collection.contentMimeTypes().toSet();
                                                 return mimeTypes.intersect(allowedMimeTypes).isEmpty();
                                              }),
                               collections.end());
         }
 
         if (m_type != Base) {
             // Replace the dummy parents in the ancestor chain with proper ones
             // full of juicy data
             std::function<Collection(const Collection&)> reconstructAncestors =
             [collectionsMap, &reconstructAncestors, this] (const Collection &collection) -> Collection {
                 Q_ASSERT(collection.isValid());
 
                 if (collection == m_collection)
                     return collection;
 
                 auto parent = collection.parentCollection();
                 auto reconstructedParent = reconstructAncestors(collectionsMap[parent.id()]);
 
                 auto result = collection;
                 result.setParentCollection(reconstructedParent);
                 return result;
             };
 
             std::transform(collections.begin(), collections.end(),
                            collections.begin(), reconstructAncestors);
         }
 
         return collections;
     }
 
     void setResource(const QString &resource) Q_DECL_OVERRIDE
     {
         fetchScope().setResource(resource);
     }
 
     void setFiltered(bool filter) Q_DECL_OVERRIDE
     {
         fetchScope().setListFilter(filter ? Akonadi::CollectionFetchScope::Display
                                           : Akonadi::CollectionFetchScope::NoFilter);
     }
 
 private:
     const Collection m_collection;
     const Type m_type;
 };
 
 class CollectionSearchJob : public CollectionFetchJob, public CollectionSearchJobInterface
 {
+    Q_OBJECT
 public:
     CollectionSearchJob(const QString &collectionName, QObject *parent = Q_NULLPTR)
         : CollectionFetchJob(Akonadi::Collection::root(),
                              CollectionJob::Recursive,
                              parent),
           m_collectionName(collectionName)
     {
     }
 
     Collection::List collections() const Q_DECL_OVERRIDE
     {
         auto collections = CollectionFetchJob::collections();
 
         // Memorize them to reconstruct the ancestor chain later
         QMap<Collection::Id, Collection> collectionsMap;
         collectionsMap[Akonadi::Collection::root().id()] = Akonadi::Collection::root();
         for (auto collection : collections) {
             collectionsMap[collection.id()] = collection;
         }
 
         // Why the hell isn't fetchScope() const and returning a reference???
         auto self = const_cast<CollectionSearchJob*>(this);
         const auto allowedMimeTypes = self->fetchScope().contentMimeTypes().toSet();
 
         collections.erase(std::remove_if(collections.begin(), collections.end(),
                                          [allowedMimeTypes, this] (const Collection &collection) {
                                             auto mimeTypes = collection.contentMimeTypes().toSet();
                                             return mimeTypes.intersect(allowedMimeTypes).isEmpty()
                                                 || !collection.displayName().contains(m_collectionName, Qt::CaseInsensitive);
                                          }),
                           collections.end());
 
         // Replace the dummy parents in the ancestor chain with proper ones
         // full of juicy data
         std::function<Collection(const Collection&)> reconstructAncestors =
         [collectionsMap, &reconstructAncestors, this] (const Collection &collection) -> Collection {
             Q_ASSERT(collection.isValid());
 
             if (collection == Akonadi::Collection::root())
                 return collection;
 
             auto parent = collection.parentCollection();
             auto reconstructedParent = reconstructAncestors(collectionsMap[parent.id()]);
 
             auto result = collection;
             result.setParentCollection(reconstructedParent);
             return result;
         };
 
         std::transform(collections.begin(), collections.end(),
                        collections.begin(), reconstructAncestors);
 
         return collections;
     }
 
 private:
     QString m_collectionName;
 };
 
 class ItemJob : public ItemFetchJob, public ItemFetchJobInterface
 {
+    Q_OBJECT
 public:
     using ItemFetchJob::ItemFetchJob;
 
     Item::List items() const Q_DECL_OVERRIDE { return ItemFetchJob::items(); }
 
     void setCollection(const Collection &collection) Q_DECL_OVERRIDE
     {
         ItemFetchJob::setCollection(collection);
     }
 };
 
 class TagJob : public TagFetchJob, public TagFetchJobInterface
 {
+    Q_OBJECT
 public:
     using TagFetchJob::TagFetchJob;
 
     Tag::List tags() const Q_DECL_OVERRIDE { return TagFetchJob::tags(); }
 };
 
 Storage::Storage()
 {
 }
 
 Storage::~Storage()
 {
 }
 
 Collection Storage::defaultTaskCollection()
 {
     return StorageSettings::instance().defaultTaskCollection();
 }
 
 Collection Storage::defaultNoteCollection()
 {
     return StorageSettings::instance().defaultNoteCollection();
 }
 
 KJob *Storage::createItem(Item item, Collection collection)
 {
     return new ItemCreateJob(item, collection);
 }
 
 KJob *Storage::updateItem(Item item, QObject *parent)
 {
     return new ItemModifyJob(item, parent);
 }
 
 KJob *Storage::removeItem(Item item)
 {
     return new ItemDeleteJob(item);
 }
 
 KJob *Storage::removeItems(Item::List items, QObject *parent)
 {
     return new ItemDeleteJob(items, parent);
 }
 
 KJob *Storage::moveItem(Item item, Collection collection, QObject *parent)
 {
     return new ItemMoveJob(item, collection, parent);
 }
 
 KJob *Storage::moveItems(Item::List items, Collection collection, QObject *parent)
 {
     return new ItemMoveJob(items, collection, parent);
 }
 
 KJob *Storage::createCollection(Collection collection, QObject *parent)
 {
     return new CollectionCreateJob(collection, parent);
 }
 
 KJob *Storage::updateCollection(Collection collection, QObject *parent)
 {
     return new CollectionModifyJob(collection, parent);
 }
 
 KJob *Storage::removeCollection(Collection collection, QObject *parent)
 {
     return new CollectionDeleteJob(collection, parent);
 }
 
 KJob *Storage::createTransaction()
 {
     return new TransactionSequence();
 }
 
 KJob *Storage::createTag(Tag tag)
 {
     return new TagCreateJob(tag);
 }
 
 KJob *Storage::updateTag(Tag tag)
 {
     return new TagModifyJob(tag);
 }
 
 KJob *Storage::removeTag(Tag tag)
 {
     return new Akonadi::TagDeleteJob(tag);
 }
 
 CollectionFetchJobInterface *Storage::fetchCollections(Collection collection, StorageInterface::FetchDepth depth, FetchContentTypes types)
 {
     QStringList contentMimeTypes;
     if (types & Notes)
         contentMimeTypes << NoteUtils::noteMimeType();
     if (types & Tasks)
         contentMimeTypes << KCalCore::Todo::todoMimeType();
 
     auto job = new CollectionJob(collection, jobTypeFromDepth(depth));
 
     auto scope = job->fetchScope();
     scope.setContentMimeTypes(contentMimeTypes);
     scope.setIncludeStatistics(true);
     scope.setAncestorRetrieval(CollectionFetchScope::All);
     scope.setListFilter(Akonadi::CollectionFetchScope::Display);
     job->setFetchScope(scope);
 
     return job;
 }
 
 CollectionSearchJobInterface *Storage::searchCollections(QString collectionName, FetchContentTypes types)
 {
     QStringList contentMimeTypes;
     if (types & Notes)
         contentMimeTypes << NoteUtils::noteMimeType();
     if (types & Tasks)
         contentMimeTypes << KCalCore::Todo::todoMimeType();
 
     auto job = new CollectionSearchJob(collectionName);
 
     auto scope = job->fetchScope();
     scope.setContentMimeTypes(contentMimeTypes);
     scope.setIncludeStatistics(true);
     scope.setAncestorRetrieval(CollectionFetchScope::All);
     scope.setListFilter(Akonadi::CollectionFetchScope::NoFilter);
     job->setFetchScope(scope);
 
     return job;
 }
 
 
 ItemFetchJobInterface *Storage::fetchItems(Collection collection)
 {
     auto job = new ItemJob(collection);
 
     configureItemFetchJob(job);
 
     return job;
 }
 
 ItemFetchJobInterface *Storage::fetchItem(Akonadi::Item item)
 {
     auto job = new ItemJob(item);
 
     configureItemFetchJob(job);
 
     return job;
 }
 
 ItemFetchJobInterface *Storage::fetchTagItems(Tag tag)
 {
     auto job = new ItemJob(tag);
 
     configureItemFetchJob(job);
 
     return job;
 }
 
 TagFetchJobInterface *Storage::fetchTags()
 {
     return new TagJob;
 }
 
 CollectionFetchJob::Type Storage::jobTypeFromDepth(StorageInterface::FetchDepth depth)
 {
     auto jobType = CollectionJob::Base;
 
     switch (depth) {
     case Base:
         jobType = CollectionJob::Base;
         break;
     case FirstLevel:
         jobType = CollectionJob::FirstLevel;
         break;
     case Recursive:
         jobType = CollectionJob::Recursive;
         break;
     default:
         qFatal("Unexpected enum value");
         break;
     }
 
     return jobType;
 }
 
 void Storage::configureItemFetchJob(ItemJob *job)
 {
     auto scope = job->fetchScope();
     scope.fetchFullPayload();
     scope.fetchAllAttributes();
     scope.setFetchTags(true);
     scope.tagFetchScope().setFetchIdOnly(false);
     scope.setAncestorRetrieval(ItemFetchScope::All);
     job->setFetchScope(scope);
 }
+
+#include "akonadistorage.moc"
diff --git a/src/widgets/newprojectdialog.cpp b/src/widgets/newprojectdialog.cpp
index c582548f..6db85cdd 100644
--- a/src/widgets/newprojectdialog.cpp
+++ b/src/widgets/newprojectdialog.cpp
@@ -1,118 +1,121 @@
 /* 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 "newprojectdialog.h"
 
 #include "ui_newprojectdialog.h"
 
 #include <QPushButton>
 #include <QSortFilterProxyModel>
 #include <KDescendantsProxyModel>
 
 #include "presentation/querytreemodelbase.h"
 
 using namespace Widgets;
 
 class TaskSourceProxy : public QSortFilterProxyModel
 {
+    Q_OBJECT
 public:
     explicit TaskSourceProxy(QObject *parent = Q_NULLPTR)
         : QSortFilterProxyModel(parent)
     {
         setDynamicSortFilter(true);
     }
 
 protected:
     bool filterAcceptsRow(int sourceRow, const QModelIndex &) const Q_DECL_OVERRIDE
     {
         auto sourceIndex = sourceModel()->index(sourceRow, 0);
         auto source = sourceIndex.data(Presentation::QueryTreeModelBase::ObjectRole)
                                  .value<Domain::DataSource::Ptr>();
         return source && (source->contentTypes() & Domain::DataSource::Tasks);
     }
 };
 
 NewProjectDialog::NewProjectDialog(QWidget *parent)
     : QDialog(parent),
       ui(new Ui::NewProjectDialog),
       m_flattenProxy(new KDescendantsProxyModel(this))
 {
     ui->setupUi(this);
 
     QObject::connect(ui->nameEdit, &QLineEdit::textChanged, this, &NewProjectDialog::onNameTextChanged);
     onNameTextChanged(m_name);
 
     auto taskSourceProxy = new TaskSourceProxy(this);
     taskSourceProxy->setSourceModel(m_flattenProxy);
     ui->sourceCombo->setModel(taskSourceProxy);
 
     m_flattenProxy->setDisplayAncestorData(true);
 }
 
 NewProjectDialog::~NewProjectDialog()
 {
     delete ui;
 }
 
 int NewProjectDialog::exec()
 {
     return QDialog::exec();
 }
 
 void NewProjectDialog::accept()
 {
     m_name = ui->nameEdit->text();
     m_source = ui->sourceCombo->itemData(ui->sourceCombo->currentIndex(),
                                          Presentation::QueryTreeModelBase::ObjectRole)
                               .value<Domain::DataSource::Ptr>();
     QDialog::accept();
 }
 
 void NewProjectDialog::setDataSourcesModel(QAbstractItemModel *model)
 {
     m_flattenProxy->setSourceModel(model);
     auto proxy = ui->sourceCombo->model();
     for (int row = 0; row < proxy->rowCount(); row++) {
         auto index = proxy->index(row, 0);
         if (index.data(Presentation::QueryTreeModelBase::IsDefaultRole).toBool()) {
             ui->sourceCombo->setCurrentIndex(row);
         }
     }
 }
 
 QString NewProjectDialog::name() const
 {
     return m_name;
 }
 
 Domain::DataSource::Ptr NewProjectDialog::dataSource() const
 {
     return m_source;
 }
 
 void NewProjectDialog::onNameTextChanged(const QString &text)
 {
     auto buttonOk = ui->buttonBox->button(QDialogButtonBox::Ok);
     buttonOk->setEnabled(!text.isEmpty());
 }
+
+#include "newprojectdialog.moc"
diff --git a/src/widgets/pageview.cpp b/src/widgets/pageview.cpp
index dac204c9..4c3b2a1d 100644
--- a/src/widgets/pageview.cpp
+++ b/src/widgets/pageview.cpp
@@ -1,361 +1,365 @@
 /* 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 "pageview.h"
 
 #include <QAction>
 #include <QKeyEvent>
 #include <QHeaderView>
 #include <QLabel>
 #include <QLineEdit>
 #include <QTreeView>
 #include <QVBoxLayout>
 #include <QMessageBox>
 #include <QTimer>
 
 #include "filterwidget.h"
 #include "itemdelegate.h"
 #include "messagebox.h"
 
 #include <algorithm>
 
 #include "presentation/artifactfilterproxymodel.h"
 #include "presentation/metatypes.h"
 #include "presentation/querytreemodelbase.h"
 
 namespace Widgets {
 class PageTreeView : public QTreeView
 {
+    Q_OBJECT
 public:
     using QTreeView::QTreeView;
 
 protected:
     void keyPressEvent(QKeyEvent *event) Q_DECL_OVERRIDE
     {
         if (event->key() == Qt::Key_Escape && state() != EditingState) {
             selectionModel()->clear();
         }
 
         QTreeView::keyPressEvent(event);
     }
 };
 }
 
 class PassivePopup : public QFrame
 {
+    Q_OBJECT
 public:
     explicit PassivePopup(QWidget *parent = Q_NULLPTR)
         : QFrame(parent),
           m_hideTimer(new QTimer(this)),
           m_label(new QLabel(this))
     {
         setWindowFlags(Qt::Tool
                      | Qt::X11BypassWindowManagerHint
                      | Qt::WindowStaysOnTopHint
                      | Qt::FramelessWindowHint);
         setFrameStyle(QFrame::Box | QFrame::Plain);
         setLineWidth(2);
         setAttribute(Qt::WA_DeleteOnClose);
 
         setLayout(new QVBoxLayout);
         layout()->addWidget(m_label);
 
         connect(m_hideTimer, &QTimer::timeout, this, &QWidget::hide);
     }
 
     void setVisible(bool visible) Q_DECL_OVERRIDE
     {
         if (visible) {
             m_hideTimer->start(2000);
         }
         QFrame::setVisible(visible);
     }
 
     void setText(const QString &text)
     {
         m_label->setText(text);
     }
 
 private:
     QTimer *m_hideTimer;
     QLabel *m_label;
 };
 
 using namespace Widgets;
 
 PageView::PageView(QWidget *parent)
     : QWidget(parent),
       m_cancelAction(new QAction(this)),
       m_model(Q_NULLPTR),
       m_filterWidget(new FilterWidget(this)),
       m_centralView(new PageTreeView(this)),
       m_quickAddEdit(new QLineEdit(this))
 {
     m_filterWidget->setObjectName(QStringLiteral("filterWidget"));
 
     m_centralView->setObjectName(QStringLiteral("centralView"));
     m_centralView->header()->hide();
     m_centralView->setAlternatingRowColors(true);
     m_centralView->setItemDelegate(new ItemDelegate(this));
     m_centralView->setDragDropMode(QTreeView::DragDrop);
     m_centralView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_centralView->setModel(m_filterWidget->proxyModel());
     m_centralView->installEventFilter(this);
 
     m_centralView->setItemsExpandable(false);
     m_centralView->setRootIsDecorated(false);
     connect(m_centralView->model(), &QAbstractItemModel::rowsInserted, m_centralView, &QTreeView::expandAll);
     connect(m_centralView->model(), &QAbstractItemModel::layoutChanged, m_centralView, &QTreeView::expandAll);
     connect(m_centralView->model(), &QAbstractItemModel::modelReset, m_centralView, &QTreeView::expandAll);
     m_centralView->setStyleSheet(QStringLiteral("QTreeView::branch { border-image: url(none.png); }"));
 
     m_quickAddEdit->setObjectName(QStringLiteral("quickAddEdit"));
     m_quickAddEdit->setPlaceholderText(tr("Type and press enter to add an item"));
     connect(m_quickAddEdit, &QLineEdit::editingFinished, this, &PageView::onEditingFinished);
 
     auto layout = new QVBoxLayout;
     layout->addWidget(m_filterWidget);
     layout->addWidget(m_centralView);
     layout->addWidget(m_quickAddEdit);
     setLayout(layout);
 
     m_messageBoxInterface = MessageBox::Ptr::create();
 
     auto addItemAction = new QAction(this);
     addItemAction->setObjectName(QStringLiteral("addItemAction"));
     addItemAction->setText(tr("New item"));
     addItemAction->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
     addItemAction->setShortcut(Qt::CTRL | Qt::Key_N);
     connect(addItemAction, &QAction::triggered, this, &PageView::onAddItemRequested);
 
     m_cancelAction->setObjectName(QStringLiteral("cancelAddItemAction"));
     m_cancelAction->setShortcut(Qt::Key_Escape);
     addAction(m_cancelAction);
     connect(m_cancelAction, &QAction::triggered,
             m_centralView, static_cast<void(QWidget::*)()>(&QWidget::setFocus));
 
     auto removeItemAction = new QAction(this);
     removeItemAction->setObjectName(QStringLiteral("removeItemAction"));
     removeItemAction->setText(tr("Remove item"));
     removeItemAction->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
     removeItemAction->setShortcut(Qt::Key_Delete);
     connect(removeItemAction, &QAction::triggered, this, &PageView::onRemoveItemRequested);
     addAction(removeItemAction);
 
     auto promoteItemAction = new QAction(this);
     promoteItemAction->setObjectName(QStringLiteral("promoteItemAction"));
     promoteItemAction->setText(tr("Promote item as project"));
     promoteItemAction->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_P);
     connect(promoteItemAction, &QAction::triggered, this, &PageView::onPromoteItemRequested);
 
     auto filterViewAction = new QAction(this);
     filterViewAction->setObjectName(QStringLiteral("filterViewAction"));
     filterViewAction->setText(tr("Filter..."));
     filterViewAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
     filterViewAction->setShortcut(Qt::CTRL | Qt::Key_F);
     connect(filterViewAction, &QAction::triggered,
             m_filterWidget, static_cast<void(QWidget::*)()>(&QWidget::setFocus));
 
     m_actions.insert(QStringLiteral("page_view_add"), addItemAction);
     m_actions.insert(QStringLiteral("page_view_remove"), removeItemAction);
     m_actions.insert(QStringLiteral("page_view_promote"), promoteItemAction);
     m_actions.insert(QStringLiteral("page_view_filter"), filterViewAction);
 }
 
 QHash<QString, QAction *> PageView::globalActions() const
 {
     return m_actions;
 }
 
 QObject *PageView::model() const
 {
     return m_model;
 }
 
 void PageView::setModel(QObject *model)
 {
     if (model == m_model)
         return;
 
     if (m_centralView->selectionModel()) {
         disconnect(m_centralView->selectionModel(), Q_NULLPTR, this, Q_NULLPTR);
     }
 
     m_filterWidget->proxyModel()->setSourceModel(Q_NULLPTR);
 
     m_model = model;
 
     setEnabled(m_model);
 
     if (!m_model)
         return;
 
     QVariant modelProperty = m_model->property("centralListModel");
     if (modelProperty.canConvert<QAbstractItemModel*>())
         m_filterWidget->proxyModel()->setSourceModel(modelProperty.value<QAbstractItemModel*>());
 
     connect(m_centralView->selectionModel(), &QItemSelectionModel::currentChanged, this, &PageView::onCurrentChanged);
 }
 
 MessageBoxInterface::Ptr PageView::messageBoxInterface() const
 {
     return m_messageBoxInterface;
 }
 
 QModelIndexList PageView::selectedIndexes() const
 {
     using namespace std::placeholders;
 
     const auto selection = m_centralView->selectionModel()->selectedIndexes();
 
     auto sourceIndices = QModelIndexList();
     std::transform(selection.constBegin(), selection.constEnd(),
                    std::back_inserter(sourceIndices ),
                    std::bind(&QSortFilterProxyModel::mapToSource, m_filterWidget->proxyModel(), _1));
 
     return sourceIndices;
 }
 
 void PageView::setMessageBoxInterface(const MessageBoxInterface::Ptr &interface)
 {
     m_messageBoxInterface = interface;
 }
 
 void PageView::onEditingFinished()
 {
     if (m_quickAddEdit->text().isEmpty())
         return;
 
     auto parentIndex = QModelIndex();
     if (m_centralView->selectionModel()->selectedIndexes().size() == 1)
         parentIndex = m_centralView->selectionModel()->selectedIndexes().first();
 
     QMetaObject::invokeMethod(m_model, "addItem",
                               Q_ARG(QString, m_quickAddEdit->text()),
                               Q_ARG(QModelIndex, parentIndex));
     m_quickAddEdit->clear();
 }
 
 void PageView::onAddItemRequested()
 {
     if (m_quickAddEdit->hasFocus())
         return;
 
     const auto editTopLeft = m_quickAddEdit->geometry().topLeft();
     const auto pos = mapToGlobal(editTopLeft);
     auto popup = new PassivePopup(m_quickAddEdit);
     popup->setText(tr("Type and press enter to add an item"));
     popup->show();
     popup->move(pos - QPoint(0, popup->height()));
 
     m_quickAddEdit->selectAll();
     m_quickAddEdit->setFocus();
 }
 
 void PageView::onRemoveItemRequested()
 {
     const QModelIndexList &currentIndexes = m_centralView->selectionModel()->selectedIndexes();
     if (currentIndexes.isEmpty())
         return;
 
     QString text;
     if (currentIndexes.size() > 1) {
         bool hasDescendants = false;
         foreach (const QModelIndex &currentIndex, currentIndexes) {
             if (!currentIndex.isValid())
                 continue;
 
             if (currentIndex.model()->rowCount(currentIndex) > 0) {
                 hasDescendants = true;
                 break;
             }
         }
 
         if (hasDescendants)
             text = tr("Do you really want to delete the selected items and their children?");
         else
             text = tr("Do you really want to delete the selected items?");
 
     } else {
         const QModelIndex &currentIndex = currentIndexes.first();
         if (!currentIndex.isValid())
             return;
 
         if (currentIndex.model()->rowCount(currentIndex) > 0)
             text = tr("Do you really want to delete the selected task and all its children?");
     }
 
     if (!text.isEmpty()) {
         QMessageBox::Button button = m_messageBoxInterface->askConfirmation(this, tr("Delete Tasks"), text);
         bool canRemove = (button == QMessageBox::Yes);
 
         if (!canRemove)
             return;
     }
 
     foreach (const QModelIndex &currentIndex, currentIndexes) {
         if (!currentIndex.isValid())
             continue;
 
         QMetaObject::invokeMethod(m_model, "removeItem", Q_ARG(QModelIndex, currentIndex));
     }
 }
 
 void PageView::onPromoteItemRequested()
 {
     QModelIndex currentIndex = m_centralView->currentIndex();
     if (!currentIndex.isValid())
         return;
     QMetaObject::invokeMethod(m_model, "promoteItem", Q_ARG(QModelIndex, currentIndex));
 }
 
 void PageView::onCurrentChanged(const QModelIndex &current)
 {
     auto data = current.data(Presentation::QueryTreeModelBase::ObjectRole);
     if (!data.isValid())
         return;
 
     auto artifact = data.value<Domain::Artifact::Ptr>();
     if (!artifact)
         return;
 
     emit currentArtifactChanged(artifact);
 }
 
 bool PageView::eventFilter(QObject *object, QEvent *event)
 {
     Q_ASSERT(object == m_centralView);
     switch(event->type()) {
     case QEvent::FocusIn:
         m_cancelAction->setEnabled(false);
         break;
     case QEvent::FocusOut:
         m_cancelAction->setEnabled(true);
         break;
     default:
         break;
     }
 
     return false;
 }
+
+#include "pageview.moc"
diff --git a/tests/units/widgets/applicationcomponentstest.cpp b/tests/units/widgets/applicationcomponentstest.cpp
index 897c1c8c..a37528d3 100644
--- a/tests/units/widgets/applicationcomponentstest.cpp
+++ b/tests/units/widgets/applicationcomponentstest.cpp
@@ -1,674 +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()
     {
         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"