diff --git a/src/columnview.cpp b/src/columnview.cpp
index ef8a5012..1414b6b4 100644
--- a/src/columnview.cpp
+++ b/src/columnview.cpp
@@ -1,1370 +1,1383 @@
 /*
  *   Copyright 2019 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   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 Library 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 "columnview.h"
 #include "columnview_p.h"
 
 #include <QAbstractItemModel>
 #include <QGuiApplication>
 #include <QStyleHints>
 #include <QQmlComponent>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QDebug>
 #include <QPropertyAnimation>
 
 
 QHash<QObject *, ColumnViewAttached *> ColumnView::m_attachedObjects = QHash<QObject *, ColumnViewAttached *>();
 
 class QmlComponentsPoolSingleton
 {
 public:
     QmlComponentsPoolSingleton()
     {}
 
     QmlComponentsPool self;
 };
 
 Q_GLOBAL_STATIC(QmlComponentsPoolSingleton, privateQmlComponentsPoolSelf)
 
 
 QmlComponentsPool::QmlComponentsPool(QObject *parent)
     : QObject(parent)
 {}
 
 void QmlComponentsPool::initialize(QQmlEngine *engine)
 {
     if (!engine || m_instance) {
         return;
     }
 
     QQmlComponent *component = new QQmlComponent(engine, this);
 
     component->setData(QByteArrayLiteral("import QtQuick 2.7\n"
         "import org.kde.kirigami 2.7 as Kirigami\n"
         "QtObject {\n"
             "id: root\n"
             "readonly property Kirigami.Units units: Kirigami.Units\n"
             "readonly property Component separator: Kirigami.Separator {"
                 "property Item column\n"
                 "visible: column.Kirigami.ColumnView.view.contentX < column.x;"
                 "anchors.top: column.top;"
                 "anchors.bottom: column.bottom;"
             "}"
         "}"), QUrl());
 
     m_instance = component->create();
     //qWarning()<<component->errors();
     Q_ASSERT(m_instance);
 
     m_separatorComponent = m_instance->property("separator").value<QQmlComponent *>();
     Q_ASSERT(m_separatorComponent);
 
     m_units = m_instance->property("units").value<QObject *>();
     Q_ASSERT(m_units);
 
     connect(m_units, SIGNAL(gridUnitChanged()), this, SIGNAL(gridUnitChanged()));
     connect(m_units, SIGNAL(longDurationChanged()), this, SIGNAL(longDurationChanged()));
 }
 
 QmlComponentsPool::~QmlComponentsPool()
 {}
 
 
 /////////
 
 ColumnViewAttached::ColumnViewAttached(QObject *parent)
     : QObject(parent)
 {}
 
 ColumnViewAttached::~ColumnViewAttached()
 {}
 
 void ColumnViewAttached::setIndex(int index)
 {
     if (!m_customFillWidth && m_view) {
         const bool oldFillWidth = m_fillWidth;
         m_fillWidth = index == m_view->count() - 1;
         if (oldFillWidth != m_fillWidth) {
             emit fillWidthChanged();
         }
     }
 
     if (index == m_index) {
         return;
     }
 
     m_index = index;
     emit indexChanged();
 }
 
 int ColumnViewAttached::index() const
 {
     return m_index;
 }
 
 void ColumnViewAttached::setFillWidth(bool fill)
 {
     if (m_view) {
         disconnect(m_view.data(), &ColumnView::countChanged, this, nullptr);
     }
     m_customFillWidth = true;
 
     if (fill == m_fillWidth) {
         return;
     }
 
     m_fillWidth = fill;
     emit fillWidthChanged();
 }
 
 bool ColumnViewAttached::fillWidth() const
 {
     return m_fillWidth;
 }
 
 qreal ColumnViewAttached::reservedSpace() const
 {
     return m_reservedSpace;
 }
 
 void ColumnViewAttached::setReservedSpace(qreal space)
 {
     if (m_view) {
         disconnect(m_view.data(), &ColumnView::columnWidthChanged, this, nullptr);
     }
     m_customReservedSpace = true;
 
     if (qFuzzyCompare(space, m_reservedSpace)) {
         return;
     }
 
     m_reservedSpace = space;
     emit reservedSpaceChanged();
 }
 
 ColumnView *ColumnViewAttached::view()
 {
     return m_view;
 }
 
 void ColumnViewAttached::setView(ColumnView *view)
 {
     if (view == m_view) {
         return;
     }
 
     if (m_view) {
         disconnect(m_view.data(), nullptr, this, nullptr);
     }
     m_view = view;
 
     if (!m_customFillWidth && m_view) {
         m_fillWidth = m_index == m_view->count() - 1;
         connect(m_view.data(), &ColumnView::countChanged, this, [this]() {
             m_fillWidth = m_index == m_view->count() - 1;
             emit fillWidthChanged();
         });
     }
     if (!m_customReservedSpace && m_view) {
         m_reservedSpace = m_view->columnWidth();
         connect(m_view.data(), &ColumnView::columnWidthChanged, this, [this]() {
             m_reservedSpace = m_view->columnWidth();
             emit reservedSpaceChanged();
         });
     }
 
     emit viewChanged();
 }
 
 QQuickItem *ColumnViewAttached::originalParent() const
 {
     return m_originalParent;
 }
 
 void ColumnViewAttached::setOriginalParent(QQuickItem *parent)
 {
     m_originalParent = parent;
 }
 
 bool ColumnViewAttached::shouldDeleteOnRemove() const
 {
     return m_shouldDeleteOnRemove;
 }
 
 void ColumnViewAttached::setShouldDeleteOnRemove(bool del)
 {
     m_shouldDeleteOnRemove = del;
 }
 
 bool ColumnViewAttached::preventStealing() const
 {
     return m_preventStealing;
 }
 
 void ColumnViewAttached::setPreventStealing(bool prevent)
 {
     if (prevent == m_preventStealing) {
         return;
     }
 
     m_preventStealing = prevent;
     emit preventStealingChanged();
 }
 
 
 
 /////////
 
 ContentItem::ContentItem(ColumnView *parent)
     : QQuickItem(parent),
       m_view(parent)
 {
     m_slideAnim = new QPropertyAnimation(this);
     m_slideAnim->setTargetObject(this);
     m_slideAnim->setPropertyName("x");
     //NOTE: the duration will be taked from kirigami units upon classBegin
     m_slideAnim->setDuration(0);
     m_slideAnim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
     connect(m_slideAnim, &QPropertyAnimation::finished, this, [this] () {
         if (!m_view->currentItem()) {
             m_view->setCurrentIndex(m_items.indexOf(m_viewAnchorItem));
         } else {
             QRectF mapped = m_view->currentItem()->mapRectToItem(m_view, QRectF(QPointF(0, 0), m_view->currentItem()->size()));
             if (!QRectF(QPointF(0, 0), m_view->size()).intersects(mapped)) {
                 m_view->setCurrentIndex(m_items.indexOf(m_viewAnchorItem));
             }
         }
     });
 }
 
 ContentItem::~ContentItem()
 {}
 
 void ContentItem::setBoundedX(qreal x)
 {
     if (!parentItem()) {
         return;
     }
     m_slideAnim->stop();
     setX(qRound(qBound(qMin(0.0, -width()+parentItem()->width()), x, 0.0)));
 }
 
 void ContentItem::animateX(qreal newX)
 {
     if (!parentItem()) {
         return;
     }
 
     const qreal to = qRound(qBound(qMin(0.0, -width()+parentItem()->width()), newX, 0.0));
 
     m_slideAnim->stop();
     m_slideAnim->setStartValue(x());
     m_slideAnim->setEndValue(to);
     m_slideAnim->start();
 }
 
 void ContentItem::snapToItem()
 {
     QQuickItem *firstItem = childAt(-x(), 0);
     if (!firstItem) {
         return;
     }
     QQuickItem *nextItem = childAt(firstItem->x() + firstItem->width() + 1, 0);
 
     //need to make the last item visible?
     if (nextItem && width() - (-x() + m_view->width()) < -x() - firstItem->x()) {
         m_viewAnchorItem = nextItem;
         animateX(-nextItem->x());
 
     //The first one found?
     } else if (-x() <= firstItem->x() + firstItem->width()/2 || !nextItem) {
         m_viewAnchorItem = firstItem;
         animateX(-firstItem->x());
 
     //the second?
     } else {
         m_viewAnchorItem = nextItem;
         animateX(-nextItem->x());
     }
 }
 
 qreal ContentItem::childWidth(QQuickItem *child)
 {
     if (!parentItem()) {
         return 0.0;
     }
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(child, true));
 
     if (m_columnResizeMode == ColumnView::SingleColumn) {
         return qRound(parentItem()->width());
 
     } else if (attached->fillWidth()) {
         return qRound(qBound(m_columnWidth, (parentItem()->width() - attached->reservedSpace()), parentItem()->width()));
 
     } else if (m_columnResizeMode == ColumnView::FixedColumns) {
         return qRound(qMin(parentItem()->width(), m_columnWidth));
 
     // DynamicColumns
     } else {
         //TODO:look for Layout size hints
         qreal width = child->implicitWidth();
 
         if (width < 1.0) {
             width = m_columnWidth;
         }
 
         return qRound(qMin(m_view->width(), width));
     }
 }
 
 void ContentItem::layoutItems()
 {
     setY(m_view->topPadding());
     setHeight(m_view->height() - m_view->topPadding() - m_view->bottomPadding());
 
+    qreal implicitWidth = 0;
+    qreal implicitHeight = 0;
     qreal partialWidth = 0;
     int i = 0;
     for (QQuickItem *child : m_items) {
         if (child->isVisible()) {
             child->setSize(QSizeF(childWidth(child), height()));
             child->setPosition(QPointF(partialWidth, 0.0));
             partialWidth += child->width();
         }
         ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(child, true));
         attached->setIndex(i++);
+
+        implicitWidth += child->implicitWidth();
+    qWarning()<<"dfdfdf"<<child<<child->implicitWidth();
+        implicitHeight = qMax(implicitHeight, child->implicitHeight());
     }
+qWarning()<<"RATTATTTATTAAA"<<implicitWidth<<implicitHeight;
     setWidth(partialWidth);
 
+    setImplicitWidth(implicitWidth);
+    setImplicitHeight(implicitHeight);
+
+    m_view->setImplicitWidth(implicitWidth);
+    m_view->setImplicitHeight(implicitHeight + m_view->topPadding() + m_view->bottomPadding());
+
     const qreal newContentX = m_viewAnchorItem ? -m_viewAnchorItem->x() : 0.0;
     if (m_shouldAnimate) {
         animateX(newContentX);
     } else {
         setBoundedX(newContentX);
     }
 
     updateVisibleItems();
 }
 
 void ContentItem::updateVisibleItems()
 {
     QList <QObject *> newItems;
 
     for (auto *item : m_items) {
         if (item->isVisible() && item->x() + x() < width() && item->x() + item->width() + x() > 0) {
             newItems << item;
         }
     }
 
     const QQuickItem *oldFirstVisibleItem = m_visibleItems.isEmpty() ? nullptr : qobject_cast<QQuickItem *>(m_visibleItems.first());
     const QQuickItem *oldLastVisibleItem = m_visibleItems.isEmpty() ? nullptr : qobject_cast<QQuickItem *>(m_visibleItems.last());
 
     if (newItems != m_visibleItems) {
         m_visibleItems = newItems;
         emit m_view->visibleItemsChanged();
         if (!newItems.isEmpty() && m_visibleItems.first() != oldFirstVisibleItem) {
             emit m_view->firstVisibleItemChanged();
         }
         if (!newItems.isEmpty() && m_visibleItems.last() != oldLastVisibleItem) {
             emit m_view->lastVisibleItemChanged();
         }
     }
 }
 
 void ContentItem::forgetItem(QQuickItem *item)
 {
     if (!m_items.contains(item)) {
         return;
     }
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, true));
     attached->setView(nullptr);
     attached->setIndex(-1);
 
     disconnect(attached, nullptr, this, nullptr);
     disconnect(item, nullptr, this, nullptr);
     disconnect(item, nullptr, m_view, nullptr);
 
     QQuickItem *separatorItem = m_separators.take(item);
     if (separatorItem) {
         separatorItem->deleteLater();
     }
 
     const int index = m_items.indexOf(item);
     m_items.removeAll(item);
     updateVisibleItems();
     m_shouldAnimate = true;
     m_view->polish();
     item->setVisible(false);
 
     if (index <= m_view->currentIndex()) {
         m_view->setCurrentIndex(qBound(0, index - 1, m_items.count() - 1));
     }
     emit m_view->countChanged();
 }
 
 QQuickItem *ContentItem::ensureSeparator(QQuickItem *item)
 {
     QQuickItem *separatorItem = m_separators.value(item);
     
     if (!separatorItem) {
         separatorItem = qobject_cast<QQuickItem *>(privateQmlComponentsPoolSelf->self.m_separatorComponent->beginCreate(QQmlEngine::contextForObject(item)));
         if (separatorItem) {
             separatorItem->setParentItem(item);
             separatorItem->setZ(9999);
             separatorItem->setProperty("column", QVariant::fromValue(item));
             privateQmlComponentsPoolSelf->self.m_separatorComponent->completeCreate();
             m_separators[item] = separatorItem;
         }
     }
 
     return separatorItem;
 }
 
 void ContentItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
 {
     switch (change) {
     case QQuickItem::ItemChildAddedChange: {
         ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(value.item, true));
         attached->setView(m_view);
 
         //connect(attached, &ColumnViewAttached::fillWidthChanged, m_view, &ColumnView::polish);
          connect(attached, &ColumnViewAttached::fillWidthChanged, this, [this, attached](){
              m_view->polish();
              
         });
         connect(attached, &ColumnViewAttached::reservedSpaceChanged, m_view, &ColumnView::polish);
 
         value.item->setVisible(true);
 
         if (!m_items.contains(value.item)) {
             connect(value.item, &QQuickItem::widthChanged, m_view, &ColumnView::polish);
             m_items << value.item;
         }
 
         if (m_view->separatorVisible()) {
             ensureSeparator(value.item);
         }
 
         m_shouldAnimate = true;
         m_view->polish();
         emit m_view->countChanged();
         break;
     }
     case QQuickItem::ItemChildRemovedChange: {
         forgetItem(value.item);
         break;
     }
     case QQuickItem::ItemVisibleHasChanged:
         updateVisibleItems();
         if (value.boolValue) {
             m_view->polish();
         }
         break;
     default:
         break;
     }
     QQuickItem::itemChange(change, value);
 }
 
 void ContentItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
 {
     updateVisibleItems();
     QQuickItem::geometryChanged(newGeometry, oldGeometry);
 }
 
 void ContentItem::syncItemsOrder()
 {
     if (m_items == childItems()) {
         return;
     }
 
     m_items = childItems();
     //NOTE: polish() here sometimes gets indefinitely delayed and items chaging order isn't seen
     layoutItems();
 }
 
 void ContentItem::updateRepeaterModel()
 {
     if (!sender()) {
         return;
     }
 
     QObject *modelObj = sender()->property("model").value<QObject *>();
 
     if (!modelObj) {
         m_models.remove(sender());
         return;
     }
 
     if (m_models[sender()]) {
         disconnect(m_models[sender()], nullptr, this, nullptr);
     }
 
     m_models[sender()] = modelObj;
 
     QAbstractItemModel *qaim = qobject_cast<QAbstractItemModel *>(modelObj);
 
     if (qaim) {
         connect(qaim, &QAbstractItemModel::rowsMoved, this, &ContentItem::syncItemsOrder);
 
     } else {
         connect(modelObj, SIGNAL(childrenChanged()), this, SLOT(syncItemsOrder()));
     }
 }
 
 
 
 
 
 
 
 ColumnView::ColumnView(QQuickItem *parent)
     : QQuickItem(parent),
       m_contentItem(nullptr)
 {
     //NOTE: this is to *not* trigger itemChange
     m_contentItem = new ContentItem(this);
     setAcceptedMouseButtons(Qt::LeftButton | Qt::BackButton | Qt::ForwardButton);
     setFiltersChildMouseEvents(true);
 
     connect(m_contentItem->m_slideAnim, &QPropertyAnimation::finished, this, [this] () {
         m_moving = false;
         emit movingChanged();
     });
     connect(m_contentItem, &ContentItem::widthChanged, this, &ColumnView::contentWidthChanged);
     connect(m_contentItem, &ContentItem::xChanged, this, &ColumnView::contentXChanged);
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(this, true));
     attached->setView(this);
     attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(m_contentItem, true));
     attached->setView(this);
 }
 
 ColumnView::~ColumnView()
 {
 }
 
 ColumnView::ColumnResizeMode ColumnView::columnResizeMode() const
 {
     return m_contentItem->m_columnResizeMode;
 }
 
 void ColumnView::setColumnResizeMode(ColumnResizeMode mode)
 {
     if (m_contentItem->m_columnResizeMode == mode) {
         return;
     }
 
     m_contentItem->m_columnResizeMode = mode;
     if (mode == SingleColumn && m_currentItem) {
         m_contentItem->m_viewAnchorItem = m_currentItem;
     }
     m_contentItem->m_shouldAnimate = false;
     polish();
     emit columnResizeModeChanged();
 }
 
 qreal ColumnView::columnWidth() const
 {
     return m_contentItem->m_columnWidth;
 }
 
 void ColumnView::setColumnWidth(qreal width)
 {
     // Always forget the internal binding when the user sets anything, even the same value
     disconnect(&privateQmlComponentsPoolSelf->self, &QmlComponentsPool::gridUnitChanged, this, nullptr);
 
     if (m_contentItem->m_columnWidth == width) {
         return;
     }
 
     m_contentItem->m_columnWidth = width;
     m_contentItem->m_shouldAnimate = false;
     polish();
     emit columnWidthChanged();
 }
 
 int ColumnView::currentIndex() const
 {
     return m_currentIndex;
 }
 
 void ColumnView::setCurrentIndex(int index)
 {
     if (m_currentIndex == index || index < -1 || index >= m_contentItem->m_items.count()) {
         return;
     }
 
     m_currentIndex = index;
 
     if (index == -1) {
         m_currentItem.clear();
 
     } else {
         m_currentItem = m_contentItem->m_items[index];
         Q_ASSERT(m_currentItem);
         m_currentItem->forceActiveFocus();
 
         // If the current item is not on view, scroll
         QRectF mappedCurrent = m_currentItem->mapRectToItem(this,
                                             QRectF(QPointF(0, 0),
                                                    m_currentItem->size()));
 
         if (m_contentItem->m_slideAnim->state() == QAbstractAnimation::Running) {
             mappedCurrent.moveLeft(mappedCurrent.left() + m_contentItem->x() + m_contentItem->m_slideAnim->endValue().toInt());
         }
 
         //m_contentItem->m_slideAnim->stop();
 
         QRectF contentsRect(QPointF(0, 0), size());
 
         m_contentItem->m_shouldAnimate = true;
 
         if (!contentsRect.contains(mappedCurrent)) {
             m_contentItem->m_viewAnchorItem = m_currentItem;
             m_contentItem->animateX(-m_currentItem->x());
         } else {
             m_contentItem->snapToItem();
         }
     }
 
     emit currentIndexChanged();
     emit currentItemChanged();
 }
 
 QQuickItem *ColumnView::currentItem()
 {
     return m_currentItem;
 }
 
 QList<QObject *>ColumnView::visibleItems() const
 {
     return m_contentItem->m_visibleItems;
 }
 
 QQuickItem *ColumnView::firstVisibleItem() const
 {
     if (m_contentItem->m_visibleItems.isEmpty()) {
         return nullptr;
     }
 
     return qobject_cast<QQuickItem *>(m_contentItem->m_visibleItems.first());
 }
 
 QQuickItem *ColumnView::lastVisibleItem() const
 {
     if (m_contentItem->m_visibleItems.isEmpty()) {
         return nullptr;
     }
 
     return qobject_cast<QQuickItem *>(m_contentItem->m_visibleItems.last());
 }
 
 int ColumnView::count() const
 {
     return m_contentItem->m_items.count();
 }
 
 qreal ColumnView::topPadding() const
 {
     return m_topPadding;
 }
 
 void ColumnView::setTopPadding(qreal padding)
 {
     if (padding == m_topPadding) {
         return;
     }
 
     m_topPadding = padding;
     polish();
     emit topPaddingChanged();
 }
 
 qreal ColumnView::bottomPadding() const
 {
     return m_bottomPadding;
 }
 
 void ColumnView::setBottomPadding(qreal padding)
 {
     if (padding == m_bottomPadding) {
         return;
     }
 
     m_bottomPadding = padding;
     polish();
     emit bottomPaddingChanged();
 }
 
 
 QQuickItem *ColumnView::contentItem() const
 {
     return m_contentItem;
 }
 
 int ColumnView::scrollDuration() const
 {
     return m_contentItem->m_slideAnim->duration();
 }
 
 void ColumnView::setScrollDuration(int duration)
 {
     disconnect(&privateQmlComponentsPoolSelf->self, &QmlComponentsPool::longDurationChanged, this, nullptr);
 
     if (m_contentItem->m_slideAnim->duration() == duration) {
         return;
     }
 
     m_contentItem->m_slideAnim->setDuration(duration);
     emit scrollDurationChanged();
 }
 
 bool ColumnView::separatorVisible() const
 {
     return m_separatorVisible;
 }
 
 void ColumnView::setSeparatorVisible(bool visible)
 {
     if (visible == m_separatorVisible) {
         return;
     }
 
     m_separatorVisible = visible;
 
     if (visible) {
         for (QQuickItem *item : m_contentItem->m_items) {
             QQuickItem *sep = m_contentItem->ensureSeparator(item);
             if (sep) {
                 sep->setVisible(true);
             }
         }
     } else {
         for (QQuickItem *sep : m_contentItem->m_separators.values()) {
             sep->setVisible(false);
         }
     }
 
     emit separatorVisibleChanged();
 }
 
 bool ColumnView::dragging() const
 {
     return m_dragging;
 }
 
 bool ColumnView::moving() const
 {
     return m_moving;
 }
 
 qreal ColumnView::contentWidth() const
 {
     return m_contentItem->width();
 }
 
 qreal ColumnView::contentX() const
 {
     return -m_contentItem->x();
 }
 
 void ColumnView::setContentX(qreal x) const
 {
     m_contentItem->setX(qRound(-x));
 }
 
 bool ColumnView::interactive() const
 {
     return m_interactive;
 }
 
 void ColumnView::setInteractive(bool interactive)
 {
     if (m_interactive == interactive) {
         return;
     }
 
     m_interactive = interactive;
 
     if (!m_interactive) {
         if (m_dragging) {
             m_dragging = false;
             emit draggingChanged();
         }
 
         m_contentItem->snapToItem();
         setKeepMouseGrab(false);
     }
 
     emit interactiveChanged();
 }
 
 void ColumnView::addItem(QQuickItem *item)
 {
     insertItem(m_contentItem->m_items.length(), item);
 }
 
 void ColumnView::insertItem(int pos, QQuickItem *item)
 {
     if (!item || m_contentItem->m_items.contains(item)) {
         return;
     }
 
     m_contentItem->m_items.insert(qBound(0, pos, m_contentItem->m_items.length()), item);
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, true));
     attached->setOriginalParent(item->parentItem());
     attached->setShouldDeleteOnRemove(item->parentItem() == nullptr && QQmlEngine::objectOwnership(item) == QQmlEngine::JavaScriptOwnership);
     item->setParentItem(m_contentItem);
 
     item->forceActiveFocus();
     // We layout immediately to be sure all geometries are final after the return of this call
     m_contentItem->m_shouldAnimate = false;
     m_contentItem->layoutItems();
     emit contentChildrenChanged();
 
     // In order to keep the same current item we need to increase the current index if displaced
     // NOTE: just updating m_currentIndex does *not* update currentItem (which is what we need atm) while setCurrentIndex will update also currentItem
     if (m_currentIndex >= pos) {
         ++m_currentIndex;
         emit currentIndexChanged();
     }
 
     emit itemInserted(pos, item);
 }
 
 void ColumnView::moveItem(int from, int to)
 {
     if (m_contentItem->m_items.isEmpty()
         || from < 0 || from >= m_contentItem->m_items.length()
         || to < 0 || to >= m_contentItem->m_items.length()) {
         return;
     }
 
     m_contentItem->m_items.move(from, to);
     m_contentItem->m_shouldAnimate = true;
 
     if (from == m_currentIndex) {
         m_currentIndex = to;
         emit currentIndexChanged();
     } else if (from < m_currentIndex && to > m_currentIndex) {
         --m_currentIndex;
         emit currentIndexChanged();
     } else if (from > m_currentIndex && to <= m_currentIndex) {
         ++m_currentIndex;
         emit currentIndexChanged();
     }
 
     polish();
 }
 
 QQuickItem *ColumnView::removeItem(const QVariant &item)
 {
     if (item.canConvert<QQuickItem *>()) {
         return removeItem(item.value<QQuickItem *>());
     } else if (item.canConvert<int>()) {
         return removeItem(item.toInt());
     } else {
         return nullptr;
     }
 }
 
 QQuickItem *ColumnView::removeItem(QQuickItem *item)
 {
     if (m_contentItem->m_items.isEmpty() || !m_contentItem->m_items.contains(item)) {
         return nullptr;
     }
 
     const int index = m_contentItem->m_items.indexOf(item);
 
     // In order to keep the same current item we need to increase the current index if displaced
     if (m_currentIndex >= index) {
         setCurrentIndex(m_currentIndex - 1);
     }
 
     m_contentItem->forgetItem(item);
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, false));
 
     if (attached && attached->shouldDeleteOnRemove()) {
         item->deleteLater();
     } else {
         item->setParentItem(attached ? attached->originalParent() : nullptr);
     }
 
     emit itemRemoved(item);
 
     return item;
 }
 
 QQuickItem *ColumnView::removeItem(int pos)
 {
     if (m_contentItem->m_items.isEmpty()
         || pos < 0 || pos >= m_contentItem->m_items.length()) {
         return nullptr;
     }
 
     return removeItem(m_contentItem->m_items[pos]); 
 }
 
 QQuickItem *ColumnView::pop(QQuickItem *item)
 {
     QQuickItem *removed = nullptr;
 
     while (!m_contentItem->m_items.isEmpty() && m_contentItem->m_items.last() != item) {
         removed = removeItem(m_contentItem->m_items.last());
         // if no item has been passed, just pop one
         if (!item) {
             break;
         }
     }
     return removed;
 }
 
 void ColumnView::clear()
 {
     ColumnViewAttached *attached = nullptr;
 
     for (QQuickItem *item : m_contentItem->m_items) {
         attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, false));
         if (attached && attached->shouldDeleteOnRemove()) {
             item->deleteLater();
         } else {
             item->setParentItem(attached ? attached->originalParent() : nullptr);
         }
     }
     m_contentItem->m_items.clear();
     emit contentChildrenChanged();
 }
 
 bool ColumnView::containsItem(QQuickItem *item)
 {
     return m_contentItem->m_items.contains(item);
 }
 
 ColumnViewAttached *ColumnView::qmlAttachedProperties(QObject *object)
 {
     return new ColumnViewAttached(object);
 }
 
 void ColumnView::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
 {
     m_contentItem->setY(m_topPadding);
     m_contentItem->setHeight(newGeometry.height() - m_topPadding - m_bottomPadding);
     m_contentItem->m_shouldAnimate = false;
     polish();
 
     m_contentItem->updateVisibleItems();
     QQuickItem::geometryChanged(newGeometry, oldGeometry);
 }
 
 bool ColumnView::childMouseEventFilter(QQuickItem *item, QEvent *event)
 {
     if (!m_interactive || item == m_contentItem) {
         return QQuickItem::childMouseEventFilter(item, event);
     }
 
     switch (event->type()) {
     case QEvent::MouseButtonPress: {
         QMouseEvent *me = static_cast<QMouseEvent *>(event);
 
         if (me->button() != Qt::LeftButton) {
             return false;
         }
 
         m_contentItem->m_slideAnim->stop();
         if (item->property("preventStealing").toBool()) {
             m_contentItem->snapToItem();
             return false;
         }
         m_oldMouseX = m_startMouseX = mapFromItem(item, me->localPos()).x();
 
         me->setAccepted(false);
         setKeepMouseGrab(false);
 
         // On press, we set the current index of the view to the root item 
         QQuickItem *candidateItem = item;
         while (candidateItem->parentItem() && candidateItem->parentItem() != m_contentItem) {
             candidateItem = candidateItem->parentItem();
         }
         if (candidateItem->parentItem() == m_contentItem) {
             setCurrentIndex(m_contentItem->m_items.indexOf(candidateItem));
         }
         
         break;
     }
     case QEvent::MouseMove: {
         QMouseEvent *me = static_cast<QMouseEvent *>(event);
 
         if (!(me->buttons() & Qt::LeftButton)) {
             return false;
         }
 
         if ((!keepMouseGrab() && item->keepMouseGrab()) || item->property("preventStealing").toBool()) {
             m_contentItem->snapToItem();
             return false;
         }
 
         QQuickItem *candidateItem = item;
         while (candidateItem->parentItem() && candidateItem->parentItem() != m_contentItem) {
             candidateItem = candidateItem->parentItem();
         }
         if (candidateItem->parentItem() == m_contentItem) {
             ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(candidateItem, true));
             if (attached->preventStealing()) {
                 return false;
             }
         }
 
         const QPointF pos = mapFromItem(item, me->localPos());
 
         const bool wasDragging = m_dragging;
         // If a drag happened, start to steal all events, use startDragDistance * 2 to give time to widgets to take the mouse grab by themselves
         m_dragging = keepMouseGrab() || qAbs(mapFromItem(item, me->localPos()).x() - m_startMouseX) > qApp->styleHints()->startDragDistance() * 3;
 
         if (m_dragging != wasDragging) {
             m_moving = true;
             emit movingChanged();
             emit draggingChanged();
         }
 
         if (m_dragging) {
             m_contentItem->setBoundedX(m_contentItem->x() + pos.x() - m_oldMouseX);
         }
 
         m_oldMouseX = pos.x();
 
         setKeepMouseGrab(m_dragging);
         me->setAccepted(m_dragging);
         return m_dragging;
         break;
     }
     case QEvent::MouseButtonRelease: {
         QMouseEvent *me = static_cast<QMouseEvent *>(event);
 
         if (me->button() == Qt::BackButton && m_currentIndex > 0) {
             setCurrentIndex(m_currentIndex - 1);
             me->accept();
             return true;
         } else if (me->button() == Qt::ForwardButton) {
             setCurrentIndex(m_currentIndex + 1);
             me->accept();
             return true;
         }
 
         if (me->button() != Qt::LeftButton) {
             return false;
         }
 
         m_contentItem->snapToItem();
         if (m_dragging) {
             m_dragging = false;
             emit draggingChanged();
         }
 
         if (item->property("preventStealing").toBool()) {
             return false;
         }
 
         event->accept();
 
         //if a drag happened, don't pass the event
         const bool block = keepMouseGrab();
         setKeepMouseGrab(false);
 
         me->setAccepted(block);
         return block;
         break;
     }
     default:
         break;
     }
 
     return QQuickItem::childMouseEventFilter(item, event);
 }
 
 void ColumnView::mousePressEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::BackButton || event->button() == Qt::ForwardButton) {
         event->accept();
         return;
     }
 
     if (!m_interactive) {
         return;
     }
 
     m_contentItem->snapToItem();
     m_oldMouseX = event->localPos().x();
     m_startMouseX = event->localPos().x();
     setKeepMouseGrab(false);
     event->accept();
 }
 
 void ColumnView::mouseMoveEvent(QMouseEvent *event)
 {
     if (event->buttons() & Qt::BackButton || event->buttons() & Qt::ForwardButton) {
         event->accept();
         return;
     }
 
     if (!m_interactive) {
         return;
     }
 
     const bool wasDragging = m_dragging;
     // Same startDragDistance * 2 as the event filter
     m_dragging = keepMouseGrab() || qAbs(event->localPos().x() - m_startMouseX) > qApp->styleHints()->startDragDistance() * 2;
     if (m_dragging != wasDragging) {
         m_moving = true;
         emit movingChanged();
         emit draggingChanged();
     }
 
     setKeepMouseGrab(m_dragging);
 
     if (m_dragging) {
         m_contentItem->setBoundedX(m_contentItem->x() + event->pos().x() - m_oldMouseX);
     }
 
     m_oldMouseX = event->pos().x();
     event->accept();
 }
 
 void ColumnView::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::BackButton && m_currentIndex > 0) {
         setCurrentIndex(m_currentIndex - 1);
         event->accept();
         return;
     } else if (event->button() == Qt::ForwardButton) {
         setCurrentIndex(m_currentIndex + 1);
         event->accept();
         return;
     }
 
     if (!m_interactive) {
         return;
     }
 
     if (m_dragging) {
         m_dragging = false;
         emit draggingChanged();
     }
 
     m_contentItem->snapToItem();
     setKeepMouseGrab(false);
     event->accept();
 }
 
 void ColumnView::mouseUngrabEvent()
 {
     if (m_dragging) {
         m_dragging = false;
         emit draggingChanged();
     }
 
     if (m_contentItem->m_slideAnim->state() != QAbstractAnimation::Running) {
         m_contentItem->snapToItem();
     }
     setKeepMouseGrab(false);
 }
 
 void ColumnView::classBegin()
 {
     privateQmlComponentsPoolSelf->self.initialize(qmlEngine(this));
 
     auto syncColumnWidth = [this]() {
         m_contentItem->m_columnWidth = privateQmlComponentsPoolSelf->self.m_units->property("gridUnit").toInt() * 20;
         emit columnWidthChanged();
     };
 
     connect(&privateQmlComponentsPoolSelf->self, &QmlComponentsPool::gridUnitChanged, this, syncColumnWidth);
     syncColumnWidth();
 
     auto syncDuration = [this]() {
         m_contentItem->m_slideAnim->setDuration(privateQmlComponentsPoolSelf->self.m_units->property("longDuration").toInt());
         emit scrollDurationChanged();
     };
 
     connect(&privateQmlComponentsPoolSelf->self, &QmlComponentsPool::longDurationChanged, this, syncDuration);
     syncDuration();
 
     QQuickItem::classBegin();
 }
 
 void ColumnView::componentComplete()
 {
     m_complete = true;
     QQuickItem::componentComplete();
 }
 
 void ColumnView::updatePolish()
 {
     m_contentItem->layoutItems();
 }
 
 void ColumnView::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
 {
     switch (change) {
     case QQuickItem::ItemChildAddedChange:
         if (m_contentItem && value.item != m_contentItem && !value.item->inherits("QQuickRepeater")) {
             addItem(value.item);
         }
         break;
     default:
         break;
     }
     QQuickItem::itemChange(change, value);
 }
 
 void ColumnView::contentChildren_append(QQmlListProperty<QQuickItem> *prop, QQuickItem *item)
 {
     // This can only be called from QML
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return;
     }
 
     view->m_contentItem->m_items.append(item);
 
     ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, true));
     attached->setOriginalParent(item->parentItem());
     attached->setShouldDeleteOnRemove(item->parentItem() == nullptr && QQmlEngine::objectOwnership(item) == QQmlEngine::JavaScriptOwnership);
 
     item->setParentItem(view->m_contentItem);
 }
 
 int ColumnView::contentChildren_count(QQmlListProperty<QQuickItem> *prop)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return 0;
     }
 
     return view->m_contentItem->m_items.count();
 }
 
 QQuickItem *ColumnView::contentChildren_at(QQmlListProperty<QQuickItem> *prop, int index)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return nullptr;
     }
 
     if (index < 0 || index >= view->m_contentItem->m_items.count()) {
         return nullptr;
     }
     return view->m_contentItem->m_items.value(index);
 }
 
 void ColumnView::contentChildren_clear(QQmlListProperty<QQuickItem> *prop)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return;
     }
 
     return view->m_contentItem->m_items.clear();
 }
 
 QQmlListProperty<QQuickItem> ColumnView::contentChildren()
 {
     return QQmlListProperty<QQuickItem>(this, nullptr,
                                      contentChildren_append,
                                      contentChildren_count,
                                      contentChildren_at,
                                      contentChildren_clear);
 }
 
 void ColumnView::contentData_append(QQmlListProperty<QObject> *prop, QObject *object)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return;
     }
 
     view->m_contentData.append(object);
     QQuickItem *item = qobject_cast<QQuickItem *>(object);
     //exclude repeaters from layout
     if (item && item->inherits("QQuickRepeater")) {
         item->setParentItem(view);
 
         connect(item, SIGNAL(modelChanged()), view->m_contentItem, SLOT(updateRepeaterModel()));
 
     } else if (item) {
         view->m_contentItem->m_items.append(item);
 
         ColumnViewAttached *attached = qobject_cast<ColumnViewAttached *>(qmlAttachedPropertiesObject<ColumnView>(item, true));
         attached->setOriginalParent(item->parentItem());
         attached->setShouldDeleteOnRemove(view->m_complete && !item->parentItem() && QQmlEngine::objectOwnership(item) == QQmlEngine::JavaScriptOwnership);
 
         item->setParentItem(view->m_contentItem);
 
     } else {
         object->setParent(view);
     }
 }
 
 int ColumnView::contentData_count(QQmlListProperty<QObject> *prop)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return 0;
     }
 
     return view->m_contentData.count();
 }
 
 QObject *ColumnView::contentData_at(QQmlListProperty<QObject> *prop, int index)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return nullptr;
     }
 
     if (index < 0 || index >= view->m_contentData.count()) {
         return nullptr;
     }
     return view->m_contentData.value(index);
 }
 
 void ColumnView::contentData_clear(QQmlListProperty<QObject> *prop)
 {
     ColumnView *view = static_cast<ColumnView *>(prop->object);
     if (!view) {
         return;
     }
 
     return view->m_contentData.clear();
 }
 
 QQmlListProperty<QObject> ColumnView::contentData()
 {
     return QQmlListProperty<QObject>(this, nullptr,
                                      contentData_append,
                                      contentData_count,
                                      contentData_at,
                                      contentData_clear);
 }
 
 #include "moc_columnview.cpp"
diff --git a/src/controls/PageRow.qml b/src/controls/PageRow.qml
index c7418318..13d3773c 100644
--- a/src/controls/PageRow.qml
+++ b/src/controls/PageRow.qml
@@ -1,608 +1,611 @@
 /*
  *   Copyright 2016 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   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 Library General Public License for more details
  *
  *   You should have received a copy of the GNU Library 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.
  */
 
 import QtQuick 2.5
 import QtQuick.Layouts 1.2
 import QtQml.Models 2.2
 import QtQuick.Templates 2.0 as T
 import QtQuick.Controls 2.0 as QQC2
 import org.kde.kirigami 2.7
 import "private/globaltoolbar" as GlobalToolBar
 import "templates" as KT
 
 /**
  * PageRow implements a row-based navigation model, which can be used
  * with a set of interlinked information pages. Items are pushed in the
  * back of the row and the view scrolls until that row is visualized.
  * A PageRowcan show a single page or a multiple set of columns, depending
  * on the window width: on a phone a single column should be fullscreen,
  * while on a tablet or a desktop more than one column should be visible.
  * @inherit QtQuick.Templates.Control
  */
 T.Control {
     id: root
 
 //BEGIN PROPERTIES
     /**
      * This property holds the number of items currently pushed onto the view
      */
     property alias depth: columnView.count
 
     /**
      * The last Page in the Row
      */
     readonly property Item lastItem: columnView.contentChildren.length > 0 ?  columnView.contentChildren[columnView.contentChildren.length - 1] : null
 
     /**
      * The currently visible Item
      */
     property alias currentItem: columnView.currentItem
 
     /**
      * the index of the currently visible Item
      */
     property alias currentIndex: columnView.currentIndex
 
     /**
      * The initial item when this PageRow is created
      */
     property variant initialPage
 
     /**
      * The main ColumnView of this Row
      */
     contentItem: columnView
 
     /**
      * items: list<Item>
      * All the items that are present in the PageRow
      * @since 2.6
      */
     property alias items: columnView.contentChildren;
 
     /**
      * visibleItems: list<Item>
      * All pages which are visible in the PageRow, excluding those which are scrolled away
      * @since 2.6
      */
     property alias visibleItems: columnView.visibleItems
 
     /**
      * firstVisibleItem: Item
      * The first at least partially visible page in the PageRow, pages before that one will be out of the viewport
      * @since 2.6
      */
     property alias firstVisibleItem: columnView.firstVisibleItem
 
     /**
      * lastVisibleItem: Item
      * The last at least partially visible page in the PageRow, pages after that one will be out of the viewport
      * @since 2.6
      */
     property alias lastVisibleItem: columnView.lastVisibleItem
 
     /**
      * The default width for a column
      * default is wide enough for 30 grid units.
      * Pages can override it with their Layout.fillWidth,
      * implicitWidth Layout.minimumWidth etc.
      */
     property int defaultColumnWidth: Units.gridUnit * 20
 
     /**
      * interactive: bool
      * If true it will be possible to go back/forward by dragging the
      * content themselves with a gesture.
      * Otherwise the only way to go back will be programmatically
      * default: true
      */
     property alias interactive: columnView.interactive
 
     /**
      * wideMode: bool
      * If true, the PageRow is wide enough that willshow more than one column at once
      * @since 5.37
      */
     readonly property bool wideMode: root.width >= root.defaultColumnWidth*2 && depth >= 2
 
     /**
      * separatorVisible: bool
      * True if the separator between pages should be visible
      * default: true
      * @since 5.38
      */
     property alias separatorVisible: columnView.separatorVisible
 
     /**
      * globalToolBar: grouped property
      * Controls the appearance of an optional global toolbar for the whole PageRow.
      * It's a grouped property comprised of the following properties:
      * * style: (Kirigami.ApplicationHeaderStyle) can have the following values:
      *   ** Auto: depending on application formfactor, it can behave automatically like other values, such as a Breadcrumb on mobile and ToolBar on desktop
      *   ** Breadcrumb: it will show a breadcrumb of all the page titles in the stack, for easy navigation
      *   ** Titles: each page will only have its own tile on top 
      *   ** TabBar: the global toolbar will look like a TabBar to select the pages
      *   ** ToolBar: each page will have the title on top together buttons and menus to represent all of the page actions: not available on Mobile systems.
      *   ** None: no global toolbar will be shown
      *
      * * actualStyle: this will represent the actual style of the toolbar: it can be different from style in the case style is Auto
      * * showNavigationButtons: if true, forward and backward navigation buttons will be shown on the left of the toolbar
      * * minimumHeight: (int) minimum height of the header, which will be resized when scrolling, only in Mobile mode (default: preferredHeight, sliding but no scaling)
     property int preferredHeight: (int) the height the toolbar will usually have
     property int maximumHeight: (int) The height the toolbar will have in mobile mode when the app is in reachable mode (default: preferredHeight * 1.5)
      * * leftReservedSpace: (int, readonly) how many pixels are reserved at the left of the page toolBar (for navigation buttons or drawer handle)
     property int rightReservedSpace: (int, readonly) how many pixels are reserved at the right of the page toolbar (drawer handle)
      * @since 5.48
      */
     readonly property alias globalToolBar: globalToolBar
+
+    implicitWidth: contentItem.implicitWidth + leftPadding + rightPadding
+    implicitHeight: contentItem.implicitHeight + topPadding + bottomPadding
 //END PROPERTIES
 
 //BEGIN FUNCTIONS
     /**
      * Pushes a page on the stack.
      * The page can be defined as a component, item or string.
      * If an item is used then the page will get re-parented.
      * If a string is used then it is interpreted as a url that is used to load a page 
      * component.
      * The last pushed page will become the current item.
      *
      * @param page The page can also be given as an array of pages.
      *     In this case all those pages will
      *     be pushed onto the stack. The items in the stack can be components, items or
      *     strings just like for single pages.
      *     Additionally an object can be used, which specifies a page and an optional
      *     properties property.
      *     This can be used to push multiple pages while still giving each of
      *     them properties.
      *     When an array is used the transition animation will only be to the last page.
      *
      * @param properties The properties argument is optional and allows defining a
      * map of properties to set on the page. If page is actually an array of pages, properties should also be an array of key/value maps
      * @return The new created page (or the last one if it was an array)
      */
     function push(page, properties) {
         var item = insertPage(depth, page, properties);
         currentIndex = depth - 1;
         return item;
     }
 
     /**
      * Inserts a new page or a list of new at an arbitrary position
      * The page can be defined as a component, item or string.
      * If an item is used then the page will get re-parented.
      * If a string is used then it is interpreted as a url that is used to load a page 
      * component.
      * The current Page will not be changed, currentIndex will be adjusted
      * accordingly if needed to keep the same current page.
      *
      * @param page The page can also be given as an array of pages.
      *     In this case all those pages will
      *     be pushed onto the stack. The items in the stack can be components, items or
      *     strings just like for single pages.
      *     Additionally an object can be used, which specifies a page and an optional
      *     properties property.
      *     This can be used to push multiple pages while still giving each of
      *     them properties.
      *     When an array is used the transition animation will only be to the last page.
      *
      * @param properties The properties argument is optional and allows defining a
      * map of properties to set on the page. If page is actually an array of pages, properties should also be an array of key/value maps
      * @return The new created page (or the last one if it was an array)
      * @since 2.7
      */
     function insertPage(position, page, properties) {
         //don't push again things already there
         if (page.createObject === undefined && typeof page != "string" && columnView.containsItem(page)) {
             print("The item " + page + " is already in the PageRow");
             return null;
         }
 
         position = Math.max(0, Math.min(depth, position));
 
         columnView.pop(columnView.currentItem);
 
         // figure out if more than one page is being pushed
         var pages;
         var propsArray = [];
         if (page instanceof Array) {
             pages = page;
             page = pages.pop();
             //compatibility with pre-qqc1 api, can probably be removed
             if (page.createObject === undefined && page.parent === undefined && typeof page != "string") {
                 properties = properties || page.properties;
                 page = page.page;
             }
         }
         if (properties instanceof Array) {
             propsArray = properties;
             properties = propsArray.pop();
         } else {
             propsArray = [properties];
         }
 
         // push any extra defined pages onto the stack
         if (pages) {
             var i;
             for (i = 0; i < pages.length; i++) {
                 var tPage = pages[i];
                 var tProps = propsArray[i];
                 //compatibility with pre-qqc1 api, can probably be removed
                 if (tPage.createObject === undefined && tPage.parent === undefined && typeof tPage != "string") {
                     if (columnView.containsItem(tPage)) {
                         print("The item " + page + " is already in the PageRow");
                         continue;
                     }
                     tProps = tPage.properties;
                     tPage = tPage.page;
                 }
 
                 var pageItem = pagesLogic.initAndInsertPage(position, tPage, tProps);
                 ++position;
             }
         }
 
         // initialize the page
         var pageItem = pagesLogic.initAndInsertPage(position, page, properties);
 
         pagePushed(pageItem);
 
         return pageItem;
     }
 
     /**
      * Move the page at position fromPos to the new position toPos
      * If needed, currentIndex will be adjusted
      * in order to keep the same current page.
      * @since 2.7
      */
     function movePage(fromPos, toPos) {
         columnView.moveItem(fromPos, toPos);
     }
 
     /**
      * Remove the given page 
      * @param page The page can be given both as integer position or by reference
      * @return The page that has just been removed
      * @since 2.7
      */
     function removePage(page) {
         if (depth == 0) {
             return null;
         }
 
         return columnView.removeItem(page);
     }
 
     /**
      * Pops a page off the stack.
      * @param page If page is specified then the stack is unwound to that page,
      * to unwind to the first page specify
      * page as null.
      * @return The page instance that was popped off the stack.
      */
     function pop(page) {
         if (depth == 0) {
             return null;
         }
 
         return columnView.pop(page);
     }
 
     /**
      * Emitted when a page has been inserted anywhere
      * @param position where the page has been inserted
      * @param page the new page
      * @since 2.7
      */
     signal pageInserted(int position, Item page)
 
     /**
      * Emitted when a page has been pushed to the bottom
      * @param page the new page
      * @since 2.5
      */
     signal pagePushed(Item page)
 
     /**
      * Emitted when a page has been removed from the row.
      * @param page the page that has been removed: at this point it's still valid,
      *           but may be auto deleted soon.
      * @since 2.5
      */
     signal pageRemoved(Item page)
 
     /**
      * Replaces a page on the stack.
      * @param page The page can also be given as an array of pages.
      *     In this case all those pages will
      *     be pushed onto the stack. The items in the stack can be components, items or
      *     strings just like for single pages.
      *     the current page and all pagest after it in the stack will be removed.
      *     Additionally an object can be used, which specifies a page and an optional
      *     properties property.
      *     This can be used to push multiple pages while still giving each of
      *     them properties.
      *     When an array is used the transition animation will only be to the last page.
      * @param properties The properties argument is optional and allows defining a
      * map of properties to set on the page.
      * @see push() for details.
      */
     function replace(page, properties) {
         if (currentIndex >= 1) {
             pop(columnView.contentChildren[currentIndex-1]);
         } else if (currentIndex == 0) {
             pop();
         } else {
             console.warn("There's no page to replace");
         }
         return push(page, properties);
     }
 
     /**
      * Clears the page stack.
      * Destroy (or reparent) all the pages contained.
      */
     function clear() {
         return columnView.clear();
     }
 
     /**
      * @return the page at idx
      * @param idx the depth of the page we want
      */
     function get(idx) {
         return columnView.contentChildren[idx];
     }
 
     /**
      * go back to the previous index and scroll to the left to show one more column
      */
     function flickBack() {
         if (depth > 1) {
             currentIndex = Math.max(0, currentIndex - 1);
         }
     }
 
     /**
      * layers: QtQuick.Controls.PageStack
      * Access to the modal layers.
      * Sometimes an application needs a modal page that always covers all the rows.
      * For instance the full screen image of an image viewer or a settings page.
      * @since 5.38
      */
     property alias layers: layersStack
 //END FUNCTIONS
 
     onInitialPageChanged: {
         if (initialPage) {
             clear();
             push(initialPage, null)
         }
     }
 
     Keys.forwardTo: [currentItem]
 
     GlobalToolBar.PageRowGlobalToolBarStyleGroup {
         id: globalToolBar
         readonly property int leftReservedSpace: globalToolBarUI.item ? globalToolBarUI.item.leftReservedSpace : 0
         readonly property int rightReservedSpace: globalToolBarUI.item ? globalToolBarUI.item.rightReservedSpace : 0
         readonly property int height: globalToolBarUI.height
         readonly property Item leftHandleAnchor: globalToolBarUI.item ? globalToolBarUI.item.leftHandleAnchor : null
         readonly property Item rightHandleAnchor: globalToolBarUI.item ? globalToolBarUI.item.rightHandleAnchor : null
     }
 
     QQC2.StackView {
         id: layersStack
         z: 99
         anchors {
             fill: parent
         }
         //placeholder as initial item
         initialItem: columnView
 
         function clear () {
             //don't let it kill the main page row
             var d = root.depth;
             for (var i = 1; i < d; ++i) {
                 pop();
             } 
         }
 
         popEnter: Transition {
             OpacityAnimator {
                 from: 0
                 to: 1
                 duration: Units.longDuration
                 easing.type: Easing.InOutCubic
             }
         }
         popExit: Transition {
             ParallelAnimation {
                 OpacityAnimator {
                     from: 1
                     to: 0
                     duration: Units.longDuration
                     easing.type: Easing.InOutCubic
                 }
                 YAnimator {
                     from: 0
                     to: height/2
                     duration: Units.longDuration
                     easing.type: Easing.InCubic
                 }
             }
         }
 
         pushEnter: Transition {
             ParallelAnimation {
                 //NOTE: It's a PropertyAnimation instead of an Animator because with an animator the item will be visible for an instant before starting to fade
                 PropertyAnimation {
                     property: "opacity"
                     from: 0
                     to: 1
                     duration: Units.longDuration
                     easing.type: Easing.InOutCubic
                 }
                 YAnimator {
                     from: height/2
                     to: 0
                     duration: Units.longDuration
                     easing.type: Easing.OutCubic 
                 }
             }
         }
 
 
         pushExit: Transition {
             OpacityAnimator {
                 from: 1
                 to: 0
                 duration: Units.longDuration
                 easing.type: Easing.InOutCubic
             }
         }
 
         replaceEnter: Transition {
             ParallelAnimation {
                 OpacityAnimator {
                     from: 0
                     to: 1
                     duration: Units.longDuration
                     easing.type: Easing.InOutCubic
                 }
                 YAnimator {
                     from: height/2
                     to: 0
                     duration: Units.longDuration
                     easing.type: Easing.OutCubic
                 }
             }
         }
 
         replaceExit: Transition {
             ParallelAnimation {
                 OpacityAnimator {
                     from: 1
                     to: 0
                     duration: Units.longDuration
                     easing.type: Easing.InCubic
                 }
                 YAnimator {
                     from: 0
                     to: -height/2
                     duration: Units.longDuration
                     easing.type: Easing.InOutCubic
                 }
             }
         }
     }
 
     Loader {
         id: globalToolBarUI
         anchors {
             left: parent.left
             top: parent.top
             right: parent.right
         }
         z: 100
         active: globalToolBar.actualStyle != ApplicationHeaderStyle.None || (firstVisibleItem && firstVisibleItem.globalToolBarStyle == ApplicationHeaderStyle.ToolBar)
         visible: active
         height: active ? implicitHeight : 0
         source: Qt.resolvedUrl("private/globaltoolbar/PageRowGlobalToolBarUI.qml");
     }
 
     QtObject {
         id: pagesLogic
         readonly property var componentCache: new Array()
 
         function initAndInsertPage(position, page, properties) {
             var pageComp;
 
             if (page.createObject) {
                 // page defined as component
                 pageComp = page;
             } else if (typeof page == "string") {
                 // page defined as string (a url)
                 pageComp = pagesLogic.componentCache[page];
                 if (!pageComp) {
                     pageComp = pagesLogic.componentCache[page] = Qt.createComponent(page);
                 }
             }
             if (pageComp) {
                 // instantiate page from component
                 // FIXME: parent directly to columnView or root?
                 page = pageComp.createObject(null, properties || {});
                 columnView.insertItem(position, page);
 
                 if (pageComp.status === Component.Error) {
                     throw new Error("Error while loading page: " + pageComp.errorString());
                 } 
             } else {
                 // copy properties to the page
                 for (var prop in properties) {
                     if (properties.hasOwnProperty(prop)) {
                         page[prop] = properties[prop];
                     }
                 }
                 columnView.insertItem(position, page);
             }
 
             return page;
         }
     }
 
     ColumnView {
         id: columnView
 
         topPadding: globalToolBarUI.item && globalToolBarUI.item.breadcrumbVisible
                     ? globalToolBarUI.height : 0
 
         // Internal hidden api for Page
         readonly property Item __pageRow: root
         columnResizeMode: root.wideMode ? ColumnView.FixedColumns : ColumnView.SingleColumn
         columnWidth: root.defaultColumnWidth
 
         onItemInserted: root.pageInserted(position, item);
         onItemRemoved: root.pageRemoved(item);
     }
 
     Rectangle {
         anchors.bottom: parent.bottom
         height: Units.smallSpacing
         x: (columnView.width - width) * (columnView.contentX / (columnView.contentWidth - columnView.width))
         width: columnView.width * (columnView.width/columnView.contentWidth)
         color: Theme.textColor
         opacity: 0
         onXChanged: {
             opacity = 0.3
             scrollIndicatorTimer.restart();
         }
         Behavior on opacity {
             OpacityAnimator {
                 duration: Units.longDuration
                 easing.type: Easing.InOutQuad
             }
         }
         Timer {
             id: scrollIndicatorTimer
             interval: Units.longDuration * 4
             onTriggered: parent.opacity = 0;
         }
     }
 }
diff --git a/src/controls/ScrollablePage.qml b/src/controls/ScrollablePage.qml
index 93606e29..954ed5b4 100644
--- a/src/controls/ScrollablePage.qml
+++ b/src/controls/ScrollablePage.qml
@@ -1,190 +1,192 @@
 /*
  *   Copyright 2015 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   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 Library General Public License for more details
  *
  *   You should have received a copy of the GNU Library 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.
  */
 
 import QtQuick 2.1
 import QtQuick.Controls 2.1
 import QtQuick.Layouts 1.2
 import org.kde.kirigami 2.4
 import "private"
 
 /**
  * ScrollablePage is a container for all the app pages: everything pushed to the
  * ApplicationWindow stackView should be a Page or ScrollablePage instabnce.
  * This Page subclass is for content that has to be scrolled around, such as
  * bigger content than the screen that would normally go in a Flickable
  * or a ListView.
  * Scrolling and scrolling indicators will be automatically managed
  *
  *
  * @code
  * ScrollablePage {
  *     id: root
  *     //The rectangle will automatically bescrollable
  *     Rectangle {
  *         width: root.width
  *         height: 99999
  *     }
  * }
  * @endcode
  *
  * Another behavior added by this class is a "scroll down to refresh" behavior
  * It also can give the contents of the flickable to have more top margins in order
  * to make possible to scroll down the list to reach it with the thumb while using the
  * phone with a single hand.
  *
  * Implementations should handle the refresh themselves as follows
  *
  * @code
  * Kirigami.ScrollablePage {
  *     id: view
  *     supportsRefreshing: true
  *     onRefreshingChanged: {
  *         if (refreshing) {
  *             myModel.refresh();
  *         }
  *     }
  *     ListView {
  *         //NOTE: MyModel doesn't come from the components,
  *         //it's purely an example on how it can be used together
  *         //some application logic that can update the list model
  *         //and signals when it's done.
  *         model: MyModel {
  *             onRefreshDone: view.refreshing = false;
  *         }
  *         delegate: BasicListItem {}
  *     }
  * }
  * [...]
  * @endcode
  *
  */
 Page {
     id: root
 
     /**
      * refreshing: bool
      * If true the list is asking for refresh and will show a loading spinner.
      * it will automatically be set to true when the user pulls down enough the list.
      * This signals the application logic to start its refresh procedure.
      * The application itself will have to set back this property to false when done.
      */
     property alias refreshing: scrollView.refreshing
 
     /**
      * supportsRefreshing: bool
      * If true the list supports the "pull down to refresh" behavior.
      * default is false.
      */
     property alias supportsRefreshing: scrollView.supportsRefreshing
 
     /**
      * flickable: Flickable
      * The main Flickable item of this page
      */
     property alias flickable: scrollView.flickableItem
 
     /**
      * verticalScrollBarPolicy: Qt.ScrollBarPolicy
      * The vertical scrollbar policy
      */
     property alias verticalScrollBarPolicy: scrollView.verticalScrollBarPolicy
 
     /**
      * horizontalScrollBarPolicy: Qt.ScrollBarPolicy
      * The horizontal scrollbar policy
      */
     property alias horizontalScrollBarPolicy: scrollView.horizontalScrollBarPolicy
 
     /**
      * The main content Item of this page.
      * In the case of a ListView or GridView, both contentItem and flickable
      * will be a pointer to the ListView (or GridView)
      * NOTE: can't be contentItem as Page's contentItem is final
      */
     default property QtObject mainItem
 
     /**
      * keyboardNavigationEnabled: bool
      * If true, and if flickable is an item view, like a ListView or
      * a GridView, it will be possible to navigate the list current item
      * to next and previous items with keyboard up/down arrow buttons.
      * Also, any key event will be forwarded to the current list item.
      * default is true.
      */
     property bool keyboardNavigationEnabled: true
 
     contentHeight: root.flickable.contentHeight
     implicitHeight: (header ? header.implicitHeight : 0) + (footer ? footer.implicitHeight : 0) + contentHeight + topPadding + bottomPadding
-    implicitWidth: root.flickable.contentItem ? root.flickable.contentItem.implicitWidth : contentItem.implicitWidth + leftPadding + rightPadding
+    implicitWidth: (root.flickable.contentItem
+                ? root.flickable.contentItem.implicitWidth
+                : contentItem.implicitWidth) + leftPadding + rightPadding
 
     Theme.colorSet: flickable && flickable.hasOwnProperty("model") ? Theme.View : Theme.Window
 
     clip: true
     contentItem: RefreshableScrollView {
         id: scrollView
         //NOTE: here to not expose it to public api
         property QtObject oldMainItem
         page: root
-        clip: false
+        clip: true
         topPadding: contentItem == flickableItem ? 0 : root.topPadding
         leftPadding: root.leftPadding
         rightPadding: root.rightPadding + (root.flickable.ScrollBar.vertical && root.flickable.ScrollBar.vertical.visible ? root.flickable.ScrollBar.vertical.width : 0)
         bottomPadding: contentItem == flickableItem ? 0 : root.bottomPadding
         anchors {
             top: root.header
                     ? root.header.bottom
                     //FIXME: for nowassuming globalToolBarItem is in a Loader, which needs to be got rid of
                     : (globalToolBarItem && globalToolBarItem.parent && globalToolBarItem.visible ?
                     globalToolBarItem.parent.bottom : parent.top)
             bottom: root.footer ? root.footer.top : parent.bottom
             left: parent.left
             right: parent.right
         }
     }
 
     anchors.topMargin: 0
 
     Keys.forwardTo: root.keyboardNavigationEnabled && root.flickable
                         ? (("currentItem" in root.flickable) && root.flickable.currentItem ?  
                            [ root.flickable.currentItem, root.flickable ] : [ root.flickable ])
                         : []
 
     //HACK to get the mainItem as the last one, all the other eventual items as an overlay
     //no idea if is the way the user expects
     onMainItemChanged: {
          if (mainItem.hasOwnProperty("anchors")) {
              scrollView.contentItem = mainItem
          //don't try to reparent drawers
          } else if (mainItem.hasOwnProperty("dragMargin")) {
              return;
         //reparent sheets
         } else if (mainItem.hasOwnProperty("sheetOpen")) {
             if (mainItem.parent === root || mainItem.parent === null) {
                 mainItem.parent = root;
             }
              root.data.push(mainItem);
              return;
         }
 
         if (scrollView.oldMainItem && scrollView.oldMainItem.hasOwnProperty("parent") && (typeof applicationWindow == 'undefined' || scrollView.oldMainItem.parent !== applicationWindow().overlay)) {
              scrollView.oldMainItem.parent = overlay
          }
          scrollView.oldMainItem = mainItem
     }
 }