diff --git a/src/columnview.cpp b/src/columnview.cpp index 47e69a82..bd5a7bd3 100644 --- a/src/columnview.cpp +++ b/src/columnview.cpp @@ -1,1536 +1,1549 @@ /* * Copyright 2019 Marco Martin * * 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 #include #include #include #include #include #include #include QHash ColumnView::m_attachedObjects = QHash(); 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;" "}\n" "readonly property Component rightSeparator: Kirigami.Separator {" "property Item column\n" "anchors.top: column.top;" "anchors.right: column.right;" "anchors.bottom: column.bottom;" "}" "}"), QUrl()); m_instance = component->create(); //qWarning()<errors(); Q_ASSERT(m_instance); m_separatorComponent = m_instance->property("separator").value(); Q_ASSERT(m_separatorComponent); m_rightSeparatorComponent = m_instance->property("rightSeparator").value(); Q_ASSERT(m_rightSeparatorComponent); m_units = m_instance->property("units").value(); 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(); if (m_view) { m_view->polish(); } } 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(); if (m_view) { m_view->polish(); } } 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(); } bool ColumnViewAttached::isPinned() const { return m_pinned; } void ColumnViewAttached::setPinned(bool pinned) { if (pinned == m_pinned) { return; } m_pinned = pinned; emit pinnedChanged(); if (m_view) { m_view->polish(); } } ///////// 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)); } } }); connect(this, &QQuickItem::xChanged, this, &ContentItem::layoutPinnedItems); } 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(viewportLeft(), 0); if (!firstItem) { return; } QQuickItem *nextItem = childAt(firstItem->x() + firstItem->width() + 1, 0); //need to make the last item visible? if (nextItem && width() - (viewportRight()) < viewportLeft() - firstItem->x()) { m_viewAnchorItem = nextItem; animateX(-nextItem->x() + m_leftPinnedSpace); //The first one found? } else if (viewportLeft() <= firstItem->x() + firstItem->width()/2 || !nextItem) { m_viewAnchorItem = firstItem; animateX(-firstItem->x() + m_leftPinnedSpace); //the second? } else { m_viewAnchorItem = nextItem; animateX(-nextItem->x() + m_leftPinnedSpace); } } qreal ContentItem::viewportLeft() const { return -x() + m_leftPinnedSpace; } qreal ContentItem::viewportRight() const { - return -x() /*- m_leftPinnedSpace*/ + m_view->width() - m_rightPinnedSpace; + return -x() + m_view->width() - m_rightPinnedSpace; } qreal ContentItem::childWidth(QQuickItem *child) { if (!parentItem()) { return 0.0; } ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(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; m_leftPinnedSpace = 0; m_rightPinnedSpace = 0; for (QQuickItem *child : m_items) { ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(child, true)); if (child->isVisible()) { if (attached->isPinned() && m_view->columnResizeMode() != ColumnView::SingleColumn) { QQuickItem *sep = nullptr; int sepWidth = 0; if (m_view->separatorVisible()) { sep = ensureRightSeparator(child); sepWidth = (sep ? sep->width() : 0); } - const int width = childWidth(child); + const qreal width = childWidth(child); child->setSize(QSizeF(width + sepWidth, height())); child->setPosition(QPointF(qMin(qMax(-x(), partialWidth), -x() + m_view->width() - child->width() + sepWidth), 0.0)); child->setZ(1); - if (partialWidth < -x()) { - m_leftPinnedSpace = qMax(m_leftPinnedSpace, child->width()); + if (partialWidth <= -x()) { + m_leftPinnedSpace = qMax(m_leftPinnedSpace, width); } else if (partialWidth > -x() + m_view->width() - child->width() + sepWidth) { m_rightPinnedSpace = qMax(m_rightPinnedSpace, child->width()); } partialWidth += width; } else { child->setSize(QSizeF(childWidth(child), height())); auto it = m_rightSeparators.find(child); if (it != m_rightSeparators.end()) { it.value()->deleteLater(); m_rightSeparators.erase(it); } child->setPosition(QPointF(partialWidth, 0.0)); child->setZ(0); partialWidth += child->width(); } } attached->setIndex(i++); implicitWidth += child->implicitWidth(); implicitHeight = qMax(implicitHeight, child->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::layoutPinnedItems() { if (m_view->columnResizeMode() == ColumnView::SingleColumn) { return; } qreal partialWidth = 0; m_leftPinnedSpace = 0; m_rightPinnedSpace = 0; for (QQuickItem *child : m_items) { ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(child, true)); if (child->isVisible()) { if (attached->isPinned()) { QQuickItem *sep = nullptr; int sepWidth = 0; if (m_view->separatorVisible()) { sep = ensureRightSeparator(child); sepWidth = (sep ? sep->width() : 0); } child->setPosition(QPointF(qMin(qMax(-x(), partialWidth), -x() + m_view->width() - child->width() + sepWidth), 0.0)); - if (partialWidth < -x()) { - m_leftPinnedSpace = qMax(m_leftPinnedSpace, child->width()); + if (partialWidth <= -x()) { + m_leftPinnedSpace = qMax(m_leftPinnedSpace, child->width() - sepWidth); } else if (partialWidth > -x() + m_view->width() - child->width() + sepWidth) { m_rightPinnedSpace = qMax(m_rightPinnedSpace, child->width()); } } partialWidth += child->width(); } } } void ContentItem::updateVisibleItems() { QList 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(m_visibleItems.first()); const QQuickItem *oldLastVisibleItem = m_visibleItems.isEmpty() ? nullptr : qobject_cast(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(qmlAttachedPropertiesObject(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(); } separatorItem = m_rightSeparators.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(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; } QQuickItem *ContentItem::ensureRightSeparator(QQuickItem *item) { QQuickItem *separatorItem = m_rightSeparators.value(item); if (!separatorItem) { separatorItem = qobject_cast(privateQmlComponentsPoolSelf->self.m_rightSeparatorComponent->beginCreate(QQmlEngine::contextForObject(item))); if (separatorItem) { separatorItem->setParentItem(item); separatorItem->setZ(9999); separatorItem->setProperty("column", QVariant::fromValue(item)); privateQmlComponentsPoolSelf->self.m_rightSeparatorComponent->completeCreate(); m_rightSeparators[item] = separatorItem; } } return separatorItem; } void ContentItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value) { switch (change) { case QQuickItem::ItemChildAddedChange: { ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(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(); 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(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(qmlAttachedPropertiesObject(this, true)); attached->setView(this); attached = qobject_cast(qmlAttachedPropertiesObject(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(m_contentItem->m_leftPinnedSpace, 0, width() - m_contentItem->m_rightPinnedSpace, height()); + QRectF contentsRect(m_contentItem->m_leftPinnedSpace, + 0, + width() - m_contentItem->m_rightPinnedSpace - m_contentItem->m_leftPinnedSpace, + height()); m_contentItem->m_shouldAnimate = true; - if (!contentsRect.contains(mappedCurrent)) { - m_contentItem->m_viewAnchorItem = m_currentItem; - m_contentItem->animateX(-m_currentItem->x() + m_contentItem->m_leftPinnedSpace); - } else { - m_contentItem->snapToItem(); + if (!m_mouseDown) { + if (!contentsRect.contains(mappedCurrent)) { + m_contentItem->m_viewAnchorItem = m_currentItem; + m_contentItem->animateX(-m_currentItem->x() + m_contentItem->m_leftPinnedSpace); + } else { + m_contentItem->snapToItem(); + } } } emit currentIndexChanged(); emit currentItemChanged(); } QQuickItem *ColumnView::currentItem() { return m_currentItem; } QListColumnView::visibleItems() const { return m_contentItem->m_visibleItems; } QQuickItem *ColumnView::firstVisibleItem() const { if (m_contentItem->m_visibleItems.isEmpty()) { return nullptr; } return qobject_cast(m_contentItem->m_visibleItems.first()); } QQuickItem *ColumnView::lastVisibleItem() const { if (m_contentItem->m_visibleItems.isEmpty()) { return nullptr; } return qobject_cast(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); } ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(item, true)); if (attached->isPinned()) { QQuickItem *sep = m_contentItem->ensureRightSeparator(item); if (sep) { sep->setVisible(true); } } } } else { for (QQuickItem *sep : m_contentItem->m_separators.values()) { sep->setVisible(false); } for (QQuickItem *sep : m_contentItem->m_rightSeparators.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(qmlAttachedPropertiesObject(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()) { return removeItem(item.value()); } else if (item.canConvert()) { 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(qmlAttachedPropertiesObject(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(qmlAttachedPropertiesObject(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(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(); + m_mouseDown = true; 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(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(qmlAttachedPropertiesObject(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(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_mouseDown = 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(); + m_mouseDown = true; 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; } + m_mouseDown = false; + 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(); } + m_mouseDown = false; + 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 *prop, QQuickItem *item) { // This can only be called from QML ColumnView *view = static_cast(prop->object); if (!view) { return; } view->m_contentItem->m_items.append(item); ColumnViewAttached *attached = qobject_cast(qmlAttachedPropertiesObject(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 *prop) { ColumnView *view = static_cast(prop->object); if (!view) { return 0; } return view->m_contentItem->m_items.count(); } QQuickItem *ColumnView::contentChildren_at(QQmlListProperty *prop, int index) { ColumnView *view = static_cast(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 *prop) { ColumnView *view = static_cast(prop->object); if (!view) { return; } return view->m_contentItem->m_items.clear(); } QQmlListProperty ColumnView::contentChildren() { return QQmlListProperty(this, nullptr, contentChildren_append, contentChildren_count, contentChildren_at, contentChildren_clear); } void ColumnView::contentData_append(QQmlListProperty *prop, QObject *object) { ColumnView *view = static_cast(prop->object); if (!view) { return; } view->m_contentData.append(object); QQuickItem *item = qobject_cast(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(qmlAttachedPropertiesObject(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 *prop) { ColumnView *view = static_cast(prop->object); if (!view) { return 0; } return view->m_contentData.count(); } QObject *ColumnView::contentData_at(QQmlListProperty *prop, int index) { ColumnView *view = static_cast(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 *prop) { ColumnView *view = static_cast(prop->object); if (!view) { return; } return view->m_contentData.clear(); } QQmlListProperty ColumnView::contentData() { return QQmlListProperty(this, nullptr, contentData_append, contentData_count, contentData_at, contentData_clear); } #include "moc_columnview.cpp" diff --git a/src/columnview.h b/src/columnview.h index e2e17366..c608297f 100644 --- a/src/columnview.h +++ b/src/columnview.h @@ -1,439 +1,440 @@ /* * Copyright 2019 Marco Martin * * 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. */ #pragma once #include #include #include class ContentItem; class ColumnView; /** * This is an attached property to every item that is inserted in the ColumnView, * used to access the view and page information such as the position and informations for layouting, such as fillWidth * @since 2.7 */ class ColumnViewAttached : public QObject { Q_OBJECT /** * The index position of the column in the view, starting from 0 */ Q_PROPERTY(int index READ index WRITE setIndex NOTIFY indexChanged) /** * If true, the column will expand to take the whole viewport space minus reservedSpace */ Q_PROPERTY(bool fillWidth READ fillWidth WRITE setFillWidth NOTIFY fillWidthChanged) /** * When a column is fillWidth, it will keep reservedSpace amount of pixels from going to fill the full viewport width */ Q_PROPERTY(qreal reservedSpace READ reservedSpace WRITE setReservedSpace NOTIFY reservedSpaceChanged) /** * Like the same property of MouseArea, when this is true, the column view won't * try to manage events by itself when filtering from a child, not * disturbing user interaction */ Q_PROPERTY(bool preventStealing READ preventStealing WRITE setPreventStealing NOTIFY preventStealingChanged) /** * If true the page will never go out of view, but will stay either * at the right or left side of the Columnview */ Q_PROPERTY(bool pinned READ isPinned WRITE setPinned NOTIFY pinnedChanged) /** * The view this column belongs to */ Q_PROPERTY(ColumnView *view READ view NOTIFY viewChanged) public: ColumnViewAttached(QObject *parent = nullptr); ~ColumnViewAttached(); void setIndex(int index); int index() const; void setFillWidth(bool fill); bool fillWidth() const; qreal reservedSpace() const; void setReservedSpace(qreal space); ColumnView *view(); void setView(ColumnView *view); //Private API, not for QML use QQuickItem *originalParent() const; void setOriginalParent(QQuickItem *parent); bool shouldDeleteOnRemove() const; void setShouldDeleteOnRemove(bool del); bool preventStealing() const; void setPreventStealing(bool prevent); bool isPinned() const; void setPinned(bool pinned); Q_SIGNALS: void indexChanged(); void fillWidthChanged(); void reservedSpaceChanged(); void viewChanged(); void preventStealingChanged(); void pinnedChanged(); private: int m_index = -1; bool m_fillWidth = false; qreal m_reservedSpace = 0; QPointer m_view; QPointer m_originalParent; bool m_customFillWidth = false; bool m_customReservedSpace = false; bool m_shouldDeleteOnRemove = true; bool m_preventStealing = false; bool m_pinned = false; }; /** * ColumnView is a container that lays out items horizontally in a row, * when not all items fit in the ColumnView, it will behave ike a Flickable and will be a scrollable view which shows only a determined number of columns. * The columns can either all have the same fixed size (recommended), * size themselves with implicitWidth, or automatically expand to take all the available width: by default the last column will always be the expanding one. * Items inside the Columnview can access info of the view and set layouting hints via the Columnview attached property. * * This is the base for the implementation of PageRow * @since 2.7 */ class ColumnView : public QQuickItem { Q_OBJECT /** * The strategy to follow while automatically resizing the columns, * the enum can have the following values: * * FixedColumns: every column is fixed at the same width of the columnWidth property * * DynamicColumns: columns take their width from their implicitWidth * * SingleColumn: only one column at a time is shown, as wide as the viewport, eventual reservedSpace on the column's atttached property is ignored */ Q_PROPERTY(ColumnResizeMode columnResizeMode READ columnResizeMode WRITE setColumnResizeMode NOTIFY columnResizeModeChanged) /** * The width of all columns when columnResizeMode is FixedColumns */ Q_PROPERTY(qreal columnWidth READ columnWidth WRITE setColumnWidth NOTIFY columnWidthChanged) /** * How many columns this view containsItem*/ Q_PROPERTY(int count READ count NOTIFY countChanged) /** * The position of the currently active column. The current column will also have keyboard focus */ Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged) /** * The currently active column. The current column will also have keyboard focus */ Q_PROPERTY(QQuickItem *currentItem READ currentItem NOTIFY currentItemChanged) /** * The main content item of this view: it's the parent of the column items */ Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT) /** * The value of the horizontal scroll of the view, in pixels */ Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged) /** * The compound width of all columns in the view */ Q_PROPERTY(qreal contentWidth READ contentWidth NOTIFY contentWidthChanged) /** * The padding this will have at the top */ Q_PROPERTY(qreal topPadding READ topPadding WRITE setTopPadding NOTIFY topPaddingChanged) /** * The padding this will have at the bottom */ Q_PROPERTY(qreal bottomPadding READ bottomPadding WRITE setBottomPadding NOTIFY bottomPaddingChanged) /** * The duration for scrolling animations */ Q_PROPERTY(int scrollDuration READ scrollDuration WRITE setScrollDuration NOTIFY scrollDurationChanged) /** * True if columns should be visually separed by a separator line */ Q_PROPERTY(bool separatorVisible READ separatorVisible WRITE setSeparatorVisible NOTIFY separatorVisibleChanged) /** * The list of all visible column items that are at least partially in the viewport at any given moment */ Q_PROPERTY(QList visibleItems READ visibleItems NOTIFY visibleItemsChanged) /** * The first of visibleItems provided from convenience */ Q_PROPERTY(QQuickItem *firstVisibleItem READ firstVisibleItem NOTIFY firstVisibleItemChanged) /** * The last of visibleItems provided from convenience */ Q_PROPERTY(QQuickItem *lastVisibleItem READ lastVisibleItem NOTIFY lastVisibleItemChanged) // Properties to make it similar to Flickable /** * True when the user is dragging around with touch gestures the view contents */ Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged) /** * True both when the user is dragging around with touch gestures the view contents or the view is animating */ Q_PROPERTY(bool moving READ moving NOTIFY movingChanged) /** * True if it supports moving the contents by dragging */ Q_PROPERTY(bool interactive READ interactive WRITE setInteractive NOTIFY interactiveChanged) // Default properties /** * Every column item the view contains */ Q_PROPERTY(QQmlListProperty contentChildren READ contentChildren NOTIFY contentChildrenChanged FINAL) /** * every item declared inside the view, both visual and non-visual items */ Q_PROPERTY(QQmlListProperty contentData READ contentData FINAL) Q_CLASSINFO("DefaultProperty", "contentData") Q_ENUMS(ColumnResizeMode) public: enum ColumnResizeMode { FixedColumns = 0, DynamicColumns, SingleColumn }; ColumnView(QQuickItem *parent = nullptr); ~ColumnView(); // QML property accessors ColumnResizeMode columnResizeMode() const; void setColumnResizeMode(ColumnResizeMode mode); qreal columnWidth() const; void setColumnWidth(qreal width); int currentIndex() const; void setCurrentIndex(int index); int scrollDuration() const; void setScrollDuration(int duration); bool separatorVisible() const; void setSeparatorVisible(bool visible); int count() const; qreal topPadding() const; void setTopPadding(qreal padding); qreal bottomPadding() const; void setBottomPadding(qreal padding); QQuickItem *currentItem(); //NOTE: It's a QList as QML can't corectly build an Array out of QList QList visibleItems() const; QQuickItem *firstVisibleItem() const; QQuickItem *lastVisibleItem() const; QQuickItem *contentItem() const; QQmlListProperty contentChildren(); QQmlListProperty contentData(); bool dragging() const; bool moving() const; qreal contentWidth() const; qreal contentX() const; void setContentX(qreal x) const; bool interactive() const; void setInteractive(bool interactive); // Api not intended for QML use //can't do overloads in QML QQuickItem *removeItem(QQuickItem *item); QQuickItem *removeItem(int item); // QML attached property static ColumnViewAttached *qmlAttachedProperties(QObject *object); public Q_SLOTS: /** * Pushes a new item at the end of the view * @param item the new item which will be reparented and managed */ void addItem(QQuickItem *item); /** * Inserts a new item in the view at a given position. * The current Item will not be changed, currentIndex will be adjusted * accordingly if needed to keep the same current item. * @param pos the position we want the new item to be inserted in * @param item the new item which will be reparented and managed */ void insertItem(int pos, QQuickItem *item); /** * Move an item inside the view. * The currentIndex property may be changed in order to keep currentItem the same. * @param from the old position * @param to the new position */ void moveItem(int from, int to); /** * Removes an item from the view. * Items will be reparented to their old parent. * If they have JavaScript ownership and they didn't have an old parent, they will be destroyed. * CurrentIndex may be changed in order to keep the same currentItem * @param item it can either be a pointer of an item or an integer specifying the position to remove * @returns the item that has just been removed */ QQuickItem *removeItem(const QVariant &item); /** * Removes all the items after item. Starting from the last column, every column will be removed until item is found, which will be left in place. * Items will be reparented to their old parent. * If they have JavaScript ownership and they didn't have an old parent, they will be destroyed * @param item the item which will be the new last one of the row. * @returns the last item that has been removed */ QQuickItem *pop(QQuickItem *item); /** * Removes every item in the view. * Items will be reparented to their old parent. * If they have JavaScript ownership and they didn't have an old parent, they will be destroyed */ void clear(); /** * @returns true if the view contains the given item */ bool containsItem(QQuickItem *item); protected: void classBegin() override; void componentComplete() override; void updatePolish() override; void itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value) override; void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override; bool childMouseEventFilter(QQuickItem *item, QEvent *event) override; void mousePressEvent(QMouseEvent *event) override; void mouseMoveEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent *event) override; void mouseUngrabEvent() override; Q_SIGNALS: /** * A new item has been inserted * @param position where the page has been inserted * @param item a pointer to the new item */ void itemInserted(int position, QQuickItem *item); /** * An item has just been removed from the view * @param item a pointer to the item that has just been removed */ void itemRemoved(QQuickItem *item); // Property notifiers void contentChildrenChanged(); void columnResizeModeChanged(); void columnWidthChanged(); void currentIndexChanged(); void currentItemChanged(); void visibleItemsChanged(); void countChanged(); void draggingChanged(); void movingChanged(); void contentXChanged(); void contentWidthChanged(); void interactiveChanged(); void scrollDurationChanged(); void separatorVisibleChanged(); void firstVisibleItemChanged(); void lastVisibleItemChanged(); void topPaddingChanged(); void bottomPaddingChanged(); private: static void contentChildren_append(QQmlListProperty *prop, QQuickItem *object); static int contentChildren_count(QQmlListProperty *prop); static QQuickItem *contentChildren_at(QQmlListProperty *prop, int index); static void contentChildren_clear(QQmlListProperty *prop); static void contentData_append(QQmlListProperty *prop, QObject *object); static int contentData_count(QQmlListProperty *prop); static QObject *contentData_at(QQmlListProperty *prop, int index); static void contentData_clear(QQmlListProperty *prop); QList m_contentData; ContentItem *m_contentItem; QPointer m_currentItem; static QHash m_attachedObjects; qreal m_oldMouseX = -1.0; qreal m_startMouseX = -1.0; int m_currentIndex = -1; qreal m_topPadding = 0; qreal m_bottomPadding = 0; + bool m_mouseDown = false; bool m_interactive = true; bool m_dragging = false; bool m_moving = false; bool m_separatorVisible = true; bool m_complete = false; }; QML_DECLARE_TYPEINFO(ColumnView, QML_HAS_ATTACHED_PROPERTIES)