diff --git a/src/renku/app/main.cpp b/src/renku/app/main.cpp
index 7f4f0155..37adcdc7 100644
--- a/src/renku/app/main.cpp
+++ b/src/renku/app/main.cpp
@@ -1,107 +1,108 @@
 /* This file is part of Renku Notes
 
    Copyright 2015 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 <QBoxLayout>
 #include <QDockWidget>
 
 #include <KActionCollection>
 
 
 #include <KXmlGuiWindow>
 #include <QApplication>
 #include <KAboutData>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 
 #include "widgets/applicationcomponents.h"
 #include "widgets/availablepagesview.h"
 #include "widgets/availablesourcesview.h"
 #include "widgets/editorview.h"
 #include "widgets/pageview.h"
 
 #include "presentation/applicationmodel.h"
 
 #include "aboutdata.h"
 #include "dependencies.h"
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     App::initializeDependencies();
 
     auto aboutData = App::getAboutData();
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     parser.addVersionOption();
     parser.addHelpOption();
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     auto widget = new QWidget;
     auto components = new Widgets::ApplicationComponents(widget);
     components->setModel(Presentation::ApplicationModel::Ptr::create());
 
     auto layout = new QVBoxLayout;
+    layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(components->pageView());
     widget->setLayout(layout);
 
     auto sourcesDock = new QDockWidget(QObject::tr("Sources"));
     sourcesDock->setObjectName(QStringLiteral("sourcesDock"));
     sourcesDock->setWidget(components->availableSourcesView());
 
     auto pagesDock = new QDockWidget(QObject::tr("Pages"));
     pagesDock->setObjectName(QStringLiteral("pagesDock"));
     pagesDock->setWidget(components->availablePagesView());
 
     auto editorDock = new QDockWidget(QObject::tr("Editor"));
     editorDock->setObjectName(QStringLiteral("editorDock"));
     editorDock->setWidget(components->editorView());
 
     auto window = new KXmlGuiWindow;
     window->setCentralWidget(widget);
 
     window->addDockWidget(Qt::RightDockWidgetArea, editorDock);
     window->addDockWidget(Qt::LeftDockWidgetArea, pagesDock);
     window->addDockWidget(Qt::LeftDockWidgetArea, sourcesDock);
 
     auto actions = components->globalActions();
     actions.insert(QStringLiteral("dock_sources"), sourcesDock->toggleViewAction());
     actions.insert(QStringLiteral("dock_pages"), pagesDock->toggleViewAction());
     actions.insert(QStringLiteral("dock_editor"), editorDock->toggleViewAction());
 
     auto ac = window->actionCollection();
     ac->addAction(KStandardAction::Quit, window, SLOT(close()));
     for (auto it = actions.constBegin(); it != actions.constEnd(); ++it) {
         ac->addAction(it.key(), it.value());
     }
 
     window->setupGUI(QSize(1024, 600),
                      KXmlGuiWindow::ToolBar
                    | KXmlGuiWindow::Keys
                    | KXmlGuiWindow::Save
                    | KXmlGuiWindow::Create);
     window->show();
 
     return app.exec();
 }
diff --git a/src/widgets/pageview.cpp b/src/widgets/pageview.cpp
index 4c3b2a1d..f7e7af6a 100644
--- a/src/widgets/pageview.cpp
+++ b/src/widgets/pageview.cpp
@@ -1,365 +1,366 @@
 /* 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->setContentsMargins(0, 0, 0, 0);
     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/src/zanshin/app/main.cpp b/src/zanshin/app/main.cpp
index cb72126a..a94e0b5e 100644
--- a/src/zanshin/app/main.cpp
+++ b/src/zanshin/app/main.cpp
@@ -1,128 +1,129 @@
 /* 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 <QApplication>
 #include <QBoxLayout>
 #include <QDockWidget>
 #include <QProcess>
 #include <QAction>
 
 #include <KActionCollection>
 
 
 #include <KXmlGuiWindow>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include "widgets/applicationcomponents.h"
 #include "widgets/availablepagesview.h"
 #include "widgets/availablesourcesview.h"
 #include "widgets/editorview.h"
 #include "widgets/pageview.h"
 
 #include "presentation/applicationmodel.h"
 
 #include "aboutdata.h"
 #include "dependencies.h"
 
 #include <iostream>
 #include <KAboutData>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv); // PORTING SCRIPT: move this to before the KAboutData initialization
     App::initializeDependencies();
 
     auto aboutData = App::getAboutData();
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     parser.addVersionOption();
     parser.addHelpOption();
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("zanshin-migratorrc"));
     KConfigGroup group = config->group("Migrations");
     if (!group.readEntry("Migrated021Projects", false)) {
         std::cerr << "Migrating data from zanshin 0.2, please wait..." << std::endl;
         QProcess proc;
         proc.start(QStringLiteral("zanshin-migrator"));
         proc.waitForFinished();
         std::cerr << "Migration done" << std::endl;
     }
 
     auto widget = new QWidget;
     auto components = new Widgets::ApplicationComponents(widget);
     components->setModel(Presentation::ApplicationModel::Ptr::create());
 
     auto layout = new QVBoxLayout;
+    layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(components->pageView());
     widget->setLayout(layout);
 
     auto sourcesDock = new QDockWidget(QObject::tr("Sources"));
     sourcesDock->setObjectName(QStringLiteral("sourcesDock"));
     sourcesDock->setWidget(components->availableSourcesView());
 
     auto pagesDock = new QDockWidget(QObject::tr("Pages"));
     pagesDock->setObjectName(QStringLiteral("pagesDock"));
     pagesDock->setWidget(components->availablePagesView());
 
     auto editorDock = new QDockWidget(QObject::tr("Editor"));
     editorDock->setObjectName(QStringLiteral("editorDock"));
     editorDock->setWidget(components->editorView());
 
     auto window = new KXmlGuiWindow;
     window->setCentralWidget(widget);
 
     window->addDockWidget(Qt::RightDockWidgetArea, editorDock);
     window->addDockWidget(Qt::LeftDockWidgetArea, pagesDock);
     window->addDockWidget(Qt::LeftDockWidgetArea, sourcesDock);
 
     auto actions = components->globalActions();
     actions.insert(QStringLiteral("dock_sources"), sourcesDock->toggleViewAction());
     actions.insert(QStringLiteral("dock_pages"), pagesDock->toggleViewAction());
     actions.insert(QStringLiteral("dock_editor"), editorDock->toggleViewAction());
 
     auto ac = window->actionCollection();
     ac->addAction(KStandardAction::Quit, window, SLOT(close()));
     for (auto it = actions.constBegin(); it != actions.constEnd(); ++it) {
         auto shortcut = it.value()->shortcut();
         if (!shortcut.isEmpty()) {
             ac->setDefaultShortcut(it.value(), shortcut);
         }
         ac->addAction(it.key(), it.value());
     }
 
     window->setupGUI(QSize(1024, 600),
                      KXmlGuiWindow::ToolBar
                    | KXmlGuiWindow::Keys
                    | KXmlGuiWindow::Save
                    | KXmlGuiWindow::Create);
     window->show();
 
     return app.exec();
 }
diff --git a/tests/units/widgets/pageviewtest.cpp b/tests/units/widgets/pageviewtest.cpp
index ad3cac7c..4143c316 100644
--- a/tests/units/widgets/pageviewtest.cpp
+++ b/tests/units/widgets/pageviewtest.cpp
@@ -1,561 +1,564 @@
 /* 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 <QHeaderView>
+#include <QLayout>
 #include <QLineEdit>
 #include <QMessageBox>
 #include <QStandardItemModel>
 #include <QTreeView>
 
 #include "domain/task.h"
 
 #include "presentation/artifactfilterproxymodel.h"
 #include "presentation/metatypes.h"
 
 #include "widgets/filterwidget.h"
 #include "widgets/itemdelegate.h"
 #include "widgets/pageview.h"
 
 #include "messageboxstub.h"
 
 class PageModelStub : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QAbstractItemModel* centralListModel READ centralListModel)
 public:
     QAbstractItemModel *centralListModel()
     {
         return &itemModel;
     }
 
     void addStubItem(const QString &title, QStandardItem *parentItem = Q_NULLPTR)
     {
         QStandardItem *item = new QStandardItem;
         item->setData(title, Qt::DisplayRole);
         if (!parentItem)
             itemModel.appendRow(item);
         else
             parentItem->appendRow(item);
 
         taskNames << title;
     }
 
     void addStubItems(const QStringList &list)
     {
         foreach (const QString &title, list) {
             addStubItem(title);
         }
     }
 
 public slots:
     void addItem(const QString &name, const QModelIndex &parentIndex)
     {
         taskNames << name;
         parentIndices << parentIndex;
     }
 
     void removeItem(const QModelIndex &index)
     {
         removedIndices << index;
     }
 
     void promoteItem(const QModelIndex &index)
     {
         promotedIndices << index;
     }
 
 public:
     QStringList taskNames;
     QList<QPersistentModelIndex> parentIndices;
     QList<QPersistentModelIndex> removedIndices;
     QList<QPersistentModelIndex> promotedIndices;
     QStandardItemModel itemModel;
 };
 
 class PageViewTest : public QObject
 {
     Q_OBJECT
 private slots:
     void shouldHaveDefaultState()
     {
         Widgets::PageView page;
+        QCOMPARE(page.contentsMargins(), QMargins(0, 0, 0, 0));
+        QCOMPARE(page.layout()->contentsMargins(), QMargins(0, 0, 0, 0));
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         QVERIFY(centralView->isVisibleTo(&page));
         QVERIFY(!centralView->header()->isVisibleTo(&page));
         QVERIFY(qobject_cast<Widgets::ItemDelegate*>(centralView->itemDelegate()));
         QVERIFY(centralView->alternatingRowColors());
         QCOMPARE(centralView->dragDropMode(), QTreeView::DragDrop);
 
         auto filter = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         QVERIFY(filter);
         QVERIFY(filter->proxyModel());
         QCOMPARE(filter->proxyModel(), centralView->model());
 
         QLineEdit *quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
         QVERIFY(quickAddEdit);
         QVERIFY(quickAddEdit->isVisibleTo(&page));
         QVERIFY(quickAddEdit->text().isEmpty());
         QCOMPARE(quickAddEdit->placeholderText(), tr("Type and press enter to add an item"));
 
         auto addAction = page.findChild<QAction*>(QStringLiteral("addItemAction"));
         QVERIFY(addAction);
         auto cancelAddAction = page.findChild<QAction*>(QStringLiteral("cancelAddItemAction"));
         QVERIFY(cancelAddAction);
         auto removeAction = page.findChild<QAction*>(QStringLiteral("removeItemAction"));
         QVERIFY(removeAction);
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
         auto filterAction = page.findChild<QAction*>(QStringLiteral("filterViewAction"));
         QVERIFY(filterAction);
 
         auto actions = page.globalActions();
         QCOMPARE(actions.value(QStringLiteral("page_view_add")), addAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_remove")), removeAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_promote")), promoteAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_filter")), filterAction);
     }
 
     void shouldDisplayListFromPageModel()
     {
         // GIVEN
         QStandardItemModel model;
 
         QObject stubPageModel;
         stubPageModel.setProperty("centralListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::PageView page;
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         auto proxyModel = qobject_cast<Presentation::ArtifactFilterProxyModel*>(centralView->model());
         QVERIFY(proxyModel);
         QVERIFY(!proxyModel->sourceModel());
 
         // WHEN
         page.setModel(&stubPageModel);
 
         // THEN
         QCOMPARE(page.model(), &stubPageModel);
         QVERIFY(page.isEnabled());
         QCOMPARE(proxyModel->sourceModel(), &model);
     }
 
     void shouldNotCrashWithNullModel()
     {
         // GIVEN
         QStandardItemModel model;
         QObject stubPageModel;
         stubPageModel.setProperty("centralListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         auto proxyModel = qobject_cast<Presentation::ArtifactFilterProxyModel*>(centralView->model());
         QVERIFY(proxyModel);
         QCOMPARE(proxyModel->sourceModel(), &model);
 
         // WHEN
         page.setModel(Q_NULLPTR);
 
         // THEN
         QVERIFY(!page.model());
         QVERIFY(!page.isEnabled());
         QVERIFY(!proxyModel->sourceModel());
     }
 
     void shouldManageFocusThroughActions()
     {
         // GIVEN
         Widgets::PageView page;
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
         auto filter = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         auto filterEdit = filter->findChild<QLineEdit*>();
         QVERIFY(filterEdit);
         page.show();
         QTest::qWaitForWindowShown(&page);
 
         centralView->setFocus();
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(!filterEdit->hasFocus());
 
         auto addAction = page.findChild<QAction*>(QStringLiteral("addItemAction"));
         auto cancelAddAction = page.findChild<QAction*>(QStringLiteral("cancelAddItemAction"));
         auto filterAction = page.findChild<QAction*>(QStringLiteral("filterViewAction"));
 
         // WHEN
         addAction->trigger();
 
         // THEN
         QVERIFY(!centralView->hasFocus());
         QVERIFY(quickAddEdit->hasFocus());
         QVERIFY(!filterEdit->hasFocus());
 
         // WHEN
         cancelAddAction->trigger();
 
         // THEN
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(!filterEdit->hasFocus());
 
         // WHEN
         filterAction->trigger();
 
         // THEN
         QVERIFY(!centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(filterEdit->hasFocus());
 
         // WHEN
         cancelAddAction->trigger();
 
         // THEN
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(!filterEdit->hasFocus());
     }
 
     void shouldCreateTasksWithNoParentWhenHittingReturnWithoutSelectedIndex()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
         QTest::keyClicks(quickAddEdit, QStringLiteral("Bar"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("Foo") << QStringLiteral("Bar"));
         QCOMPARE(stubPageModel.parentIndices.size(), 2);
         QCOMPARE(stubPageModel.parentIndices.first(), QPersistentModelIndex());
         QCOMPARE(stubPageModel.parentIndices.last(), QPersistentModelIndex());
     }
 
     void shouldCreateTasksWithNoParentWhenHittingReturnWithSeveralSelectedIndices()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index0 = stubPageModel.itemModel.index(0, 0);
         QPersistentModelIndex index1 = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index0, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->select(index1, QItemSelectionModel::Select);
 
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("A")
                                                         << QStringLiteral("B")
                                                         << QStringLiteral("C")
                                                         << QStringLiteral("Foo"));
         QCOMPARE(stubPageModel.parentIndices.size(), 1);
         QCOMPARE(stubPageModel.parentIndices.first(), QPersistentModelIndex());
     }
 
     void shouldCreateTasksWithParentWhenHittingReturnWithOneSelectedIndex()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
 
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("A")
                                                         << QStringLiteral("B")
                                                         << QStringLiteral("C")
                                                         << QStringLiteral("Foo"));
         QCOMPARE(stubPageModel.parentIndices.size(), 1);
         QCOMPARE(stubPageModel.parentIndices.first(), index);
     }
 
     void shouldDeleteItemWhenHittingTheDeleteKey()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
         QTest::qWaitForWindowShown(&page);
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QCOMPARE(stubPageModel.removedIndices.size(), 1);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
     }
 
     void shouldNoteTryToDeleteIfThereIsNoSelection()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->clearSelection();
         page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"))->setFocus();
 
         // Needed for shortcuts to work
         page.show();
         QTest::qWaitForWindowShown(&page);
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(stubPageModel.removedIndices.isEmpty());
     }
 
     void shouldDisplayNotificationWhenHittingTheDeleteKeyOnAnItemWithChildren()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B"));
         QStandardItem *parentIndex = stubPageModel.itemModel.item(1, 0);
         stubPageModel.addStubItem(QStringLiteral("C"), parentIndex);
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto msgbox = MessageBoxStub::Ptr::create();
         page.setMessageBoxInterface(msgbox);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
         QTest::qWaitForWindowShown(&page);
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(msgbox->called());
         QCOMPARE(stubPageModel.removedIndices.size(), 1);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
     }
 
     void shouldDeleteItemsWhenHittingTheDeleteKey()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
         QPersistentModelIndex index2 = stubPageModel.itemModel.index(2, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto msgbox = MessageBoxStub::Ptr::create();
         page.setMessageBoxInterface(msgbox);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->setCurrentIndex(index2, QItemSelectionModel::Select);
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
         QTest::qWaitForWindowShown(&page);
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(msgbox->called());
         QCOMPARE(stubPageModel.removedIndices.size(), 2);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
         QCOMPARE(stubPageModel.removedIndices.at(1), index2);
     }
 
     void shouldPromoteItem()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->setFocus();
 
         // WHEN
         promoteAction->trigger();
 
         // THEN
         QCOMPARE(stubPageModel.promotedIndices.size(), 1);
         QCOMPARE(stubPageModel.promotedIndices.first(), index);
     }
 
     void shouldNotTryToPromoteItemIfThereIsNoSelection()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->clear();
         centralView->setFocus();
 
         // WHEN
         promoteAction->trigger();
 
         // THEN
         QVERIFY(stubPageModel.promotedIndices.isEmpty());
     }
 
     void shouldClearCentralViewSelectionOnEscape()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
         QVERIFY(!centralView->selectionModel()->selectedIndexes().isEmpty());
 
         // WHEN
         QTest::keyClick(centralView, Qt::Key_Escape);
 
         // THEN
         QVERIFY(centralView->selectionModel()->selectedIndexes().isEmpty());
     }
 
     void shouldReturnSelectedIndexes()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         auto index = stubPageModel.itemModel.index(1, 0);
         auto index2 = stubPageModel.itemModel.index(2, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         auto filterWidget = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
 
         auto displayedModel = filterWidget->proxyModel();
         auto displayedIndex = displayedModel->index(1, 0);
         auto displayedIndex2 = displayedModel->index(2, 0);
 
         // WHEN
         centralView->selectionModel()->setCurrentIndex(displayedIndex, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->setCurrentIndex(displayedIndex2, QItemSelectionModel::Select);
 
         // THEN
         auto selectedIndexes = page.selectedIndexes();
         QCOMPARE(selectedIndexes.size(), 2);
 
         QCOMPARE(selectedIndexes.at(0), index);
         QCOMPARE(selectedIndexes.at(1), index2);
 
         QCOMPARE(selectedIndexes.at(0).model(), index.model());
         QCOMPARE(selectedIndexes.at(1).model(), index2.model());
     }
 };
 
 ZANSHIN_TEST_MAIN(PageViewTest)
 
 #include "pageviewtest.moc"