92 #include "listviewwithpageheader.h" 94 #include <QCoreApplication> 97 #include <qqmlengine.h> 98 #pragma GCC diagnostic push 99 #pragma GCC diagnostic ignored "-pedantic" 100 #include <private/qqmldelegatemodel_p.h> 101 #include <private/qqmlglobal_p.h> 102 #include <private/qquickitem_p.h> 103 #include <private/qquickanimation_p.h> 104 #pragma GCC diagnostic pop 107 qreal ListViewWithPageHeader::ListItem::height()
const 109 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
112 qreal ListViewWithPageHeader::ListItem::y()
const 114 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
117 void ListViewWithPageHeader::ListItem::setY(qreal newY)
120 m_sectionItem->setY(newY);
121 m_item->setY(newY + m_sectionItem->height());
127 bool ListViewWithPageHeader::ListItem::culled()
const 129 return QQuickItemPrivate::get(m_item)->culled;
132 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
134 QQuickItemPrivate::get(m_item)->setCulled(culled);
136 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
139 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
141 m_sectionItem = sectionItem;
144 ListViewWithPageHeader::ListViewWithPageHeader()
145 : m_delegateModel(nullptr)
146 , m_asyncRequestedIndex(-1)
147 , m_delegateValidated(false)
148 , m_firstVisibleIndex(-1)
150 , m_contentHeightDirty(false)
151 , m_headerItem(nullptr)
152 , m_previousContentY(0)
153 , m_headerItemShownHeight(0)
154 , m_sectionDelegate(nullptr)
155 , m_topSectionItem(nullptr)
156 , m_forceNoClip(false)
158 , m_inContentHeightKeepHeaderShown(false)
161 m_clipItem =
new QQuickItem(contentItem());
165 m_contentYAnimation =
new QQuickNumberAnimation(
this);
166 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
167 m_contentYAnimation->setProperty(QStringLiteral(
"contentY"));
168 m_contentYAnimation->setDuration(200);
169 m_contentYAnimation->setTargetObject(
this);
171 connect(
this, &ListViewWithPageHeader::contentWidthChanged,
this, &ListViewWithPageHeader::onContentWidthChanged);
172 connect(
this, &ListViewWithPageHeader::contentHeightChanged,
this, &ListViewWithPageHeader::onContentHeightChanged);
173 connect(
this, &ListViewWithPageHeader::heightChanged,
this, &ListViewWithPageHeader::onHeightChanged);
174 connect(m_contentYAnimation, &QQuickNumberAnimation::runningChanged,
this, &ListViewWithPageHeader::contentYAnimationRunningChanged);
176 setFlickableDirection(VerticalFlick);
179 ListViewWithPageHeader::~ListViewWithPageHeader()
183 QAbstractItemModel *ListViewWithPageHeader::model()
const 185 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
188 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
190 if (model != this->model()) {
191 if (!m_delegateModel) {
192 createDelegateModel();
194 disconnect(m_delegateModel, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
196 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
197 connect(m_delegateModel, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
198 Q_EMIT modelChanged();
206 QQmlComponent *ListViewWithPageHeader::delegate()
const 208 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
211 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
213 if (delegate != this->delegate()) {
214 if (!m_delegateModel) {
215 createDelegateModel();
219 Q_FOREACH(ListItem *item, m_visibleItems)
221 m_visibleItems.clear();
222 initializeValuesForEmptyList();
224 m_delegateModel->setDelegate(delegate);
226 Q_EMIT delegateChanged();
227 m_delegateValidated = false;
228 m_contentHeightDirty = true;
235 m_firstVisibleIndex = -1;
239 if (m_topSectionItem) {
240 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
244 QQuickItem *ListViewWithPageHeader::header()
const 249 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
251 if (m_headerItem != headerItem) {
252 qreal oldHeaderHeight = 0;
253 qreal oldHeaderY = 0;
255 oldHeaderHeight = m_headerItem->height();
256 oldHeaderY = m_headerItem->y();
257 m_headerItem->setParentItem(
nullptr);
259 m_headerItem = headerItem;
261 m_headerItem->setParentItem(contentItem());
262 m_headerItem->setZ(1);
263 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
264 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
266 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
267 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
268 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
270 m_contentHeightDirty =
true;
272 Q_EMIT headerChanged();
276 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const 278 return m_sectionDelegate;
281 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
283 if (delegate != m_sectionDelegate) {
286 m_sectionDelegate = delegate;
288 m_topSectionItem = getSectionItem(QString());
289 m_topSectionItem->setZ(3);
290 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
291 connect(m_topSectionItem, &QQuickItem::heightChanged,
this, &ListViewWithPageHeader::stickyHeaderHeightChanged);
295 Q_EMIT sectionDelegateChanged();
296 Q_EMIT stickyHeaderHeightChanged();
300 QString ListViewWithPageHeader::sectionProperty()
const 302 return m_sectionProperty;
305 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
307 if (property != m_sectionProperty) {
308 m_sectionProperty = property;
310 updateWatchedRoles();
314 Q_EMIT sectionPropertyChanged();
318 bool ListViewWithPageHeader::forceNoClip()
const 320 return m_forceNoClip;
323 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
325 if (noClip != m_forceNoClip) {
326 m_forceNoClip = noClip;
328 Q_EMIT forceNoClipChanged();
332 int ListViewWithPageHeader::stickyHeaderHeight()
const 334 return m_topSectionItem ? m_topSectionItem->height() : 0;
337 qreal ListViewWithPageHeader::headerItemShownHeight()
const 339 return m_headerItemShownHeight;
342 int ListViewWithPageHeader::cacheBuffer()
const 344 return m_cacheBuffer;
347 void ListViewWithPageHeader::setCacheBuffer(
int cacheBuffer)
349 if (cacheBuffer < 0) {
350 qmlInfo(
this) <<
"Cannot set a negative cache buffer";
354 if (cacheBuffer != m_cacheBuffer) {
355 m_cacheBuffer = cacheBuffer;
356 Q_EMIT cacheBufferChanged();
361 void ListViewWithPageHeader::positionAtBeginning()
363 if (m_delegateModel->count() <= 0)
366 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
367 if (m_firstVisibleIndex != 0) {
371 Q_FOREACH(ListItem *item, m_visibleItems)
373 m_visibleItems.clear();
374 m_firstVisibleIndex = -1;
378 ListItem *item = createItem(0, false);
381 qreal pos = item->y() + item->height();
382 const qreal bufferTo = height() + m_cacheBuffer;
383 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
384 if (!(item = createItem(modelIndex,
false)))
386 pos += item->height();
390 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
392 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
398 m_headerItem->setY(-m_minYExtent);
402 static inline bool uFuzzyCompare(qreal r1, qreal r2)
404 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
407 void ListViewWithPageHeader::showHeader()
412 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
413 if (!uFuzzyCompare(to, contentY())) {
414 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
415 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
419 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
420 if (!m_visibleItems.isEmpty()) {
422 ListItem *firstItem = m_visibleItems.first();
423 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
426 Q_EMIT headerItemShownHeightChanged();
428 m_contentYAnimation->setTo(to);
429 contentYAnimationType = ContentYAnimationShowHeader;
430 m_contentYAnimation->start();
434 int ListViewWithPageHeader::firstCreatedIndex()
const 436 return m_firstVisibleIndex;
439 int ListViewWithPageHeader::createdItemCount()
const 441 return m_visibleItems.count();
444 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const 446 ListItem *item = itemAtIndex(modelIndex);
453 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
455 ListItem *listItem = itemAtIndex(modelIndex);
457 return maximizeVisibleArea(listItem, listItem->height());
463 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
468 ListItem *listItem = itemAtIndex(modelIndex);
470 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
476 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
480 const auto listItemY = m_clipItem->y() + listItem->y();
481 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
483 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
484 m_contentYAnimation->setTo(to);
485 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
486 m_contentYAnimation->start();
487 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
488 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
491 auto realVisibleListItemY = listItemY;
492 if (m_topSectionItem) {
496 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
497 if (topSectionShown && !listItem->sectionItem()) {
498 realVisibleListItemY -= m_topSectionItem->height();
501 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
502 m_contentYAnimation->setTo(to);
503 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
504 m_contentYAnimation->start();
511 qreal ListViewWithPageHeader::minYExtent()
const 517 void ListViewWithPageHeader::componentComplete()
520 m_delegateModel->componentComplete();
522 QQuickFlickable::componentComplete();
527 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
532 if (!QQmlEngine::contextForObject(
this)->parentContext())
535 QQuickFlickable::viewportMoved(orient);
537 const qreal diff = m_previousContentY - contentY();
539 m_previousContentY = contentY();
544 void ListViewWithPageHeader::adjustHeader(qreal diff)
546 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
548 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
549 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
550 m_headerItem->setHeight(m_headerItem->implicitHeight());
554 const bool scrolledUp = m_previousContentY > contentY();
555 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
556 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
557 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
559 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
560 m_headerItemShownHeight = 0;
561 m_headerItem->setY(-m_minYExtent);
562 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
563 if (maximizeVisibleAreaRunning && diff > 0) {
565 m_headerItemShownHeight -= diff;
567 m_headerItemShownHeight += diff;
569 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
570 m_headerItemShownHeight = 0;
572 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
574 if (m_headerItemShownHeight > 0) {
575 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
576 m_headerItem->setY(contentY());
577 m_headerItemShownHeight = m_headerItem->height();
579 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
582 m_headerItem->setY(-m_minYExtent);
585 Q_EMIT headerItemShownHeightChanged();
588 m_headerItem->setY(contentY());
589 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
594 if (!showHeaderAnimationRunning) {
595 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
600 if (!m_visibleItems.isEmpty()) {
602 ListItem *firstItem = m_visibleItems.first();
603 firstItem->setY(firstItem->y() + diff);
604 if (showHeaderAnimationRunning) {
610 void ListViewWithPageHeader::createDelegateModel()
612 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
613 connect(m_delegateModel, &QQmlDelegateModel::createdItem,
this, &ListViewWithPageHeader::itemCreated);
614 if (isComponentComplete())
615 m_delegateModel->componentComplete();
616 updateWatchedRoles();
619 void ListViewWithPageHeader::refill()
624 if (!isComponentComplete()) {
628 const qreal from = contentY();
629 const qreal to = from + height();
630 const qreal bufferFrom = from - m_cacheBuffer;
631 const qreal bufferTo = to + m_cacheBuffer;
633 bool added = addVisibleItems(from, to,
false);
634 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
635 added |= addVisibleItems(bufferFrom, bufferTo,
true);
637 if (added || removed) {
638 m_contentHeightDirty =
true;
642 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
647 if (m_delegateModel->count() == 0)
655 if (!m_visibleItems.isEmpty()) {
656 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
657 item = m_visibleItems.last();
658 pos = item->y() + item->height() + m_clipItem->y();
660 bool changed =
false;
662 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
664 if (!(item = createItem(modelIndex, asynchronous)))
666 pos += item->height();
673 if (!m_visibleItems.isEmpty()) {
674 modelIndex = m_firstVisibleIndex - 1;
675 item = m_visibleItems.first();
676 pos = item->y() + m_clipItem->y();
678 while (modelIndex >= 0 && pos > fillFrom) {
680 if (!(item = createItem(modelIndex, asynchronous)))
682 pos -= item->height();
690 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
692 QQuickItem *item = listItem->m_item;
693 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
694 if (flags & QQmlDelegateModel::Destroyed) {
695 item->setParentItem(
nullptr);
697 listItem->sectionItem()->deleteLater();
701 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
703 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
704 itemPrivate->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
705 m_itemsToRelease << listItem;
708 void ListViewWithPageHeader::updateWatchedRoles()
710 if (m_delegateModel) {
711 QList<QByteArray> roles;
712 if (!m_sectionProperty.isEmpty())
713 roles << m_sectionProperty.toUtf8();
714 m_delegateModel->setWatchedRoles(roles);
718 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
720 if (!m_sectionDelegate)
723 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
725 if (modelIndex > 0) {
726 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
727 if (section == prevSection)
730 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
732 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
733 if (section == nextSection) {
735 ListItem *nextItem = itemAtIndex(modelIndex);
737 QQuickItem *sectionItem = nextItem->sectionItem();
738 nextItem->setSectionItem(
nullptr);
744 return getSectionItem(section);
747 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText)
749 QQuickItem *sectionItem =
nullptr;
751 QQmlContext *creationContext = m_sectionDelegate->creationContext();
752 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
753 context->setContextProperty(QStringLiteral(
"section"), sectionText);
754 context->setContextProperty(QStringLiteral(
"delegateIndex"), -1);
755 QObject *nobj = m_sectionDelegate->beginCreate(context);
757 QQml_setParent_noEvent(context, nobj);
758 sectionItem = qobject_cast<QQuickItem *>(nobj);
762 sectionItem->setZ(2);
763 QQml_setParent_noEvent(sectionItem, m_clipItem);
764 sectionItem->setParentItem(m_clipItem);
769 m_sectionDelegate->completeCreate();
776 void ListViewWithPageHeader::updateSectionItem(
int modelIndex)
778 ListItem *item = itemAtIndex(modelIndex);
780 const QString sectionText = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
782 bool needSectionHeader =
true;
784 if (modelIndex > 0) {
785 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
786 if (sectionText == prevSection) {
787 needSectionHeader =
false;
791 if (needSectionHeader) {
792 if (!item->sectionItem()) {
793 item->setSectionItem(getSectionItem(sectionText));
795 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
796 context->setContextProperty(QStringLiteral(
"section"), sectionText);
799 if (item->sectionItem()) {
800 item->sectionItem()->deleteLater();
801 item->setSectionItem(
nullptr);
807 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
812 if (contentY() < -m_minYExtent) {
814 }
else if (contentY() + height() > contentHeight()) {
817 bool changed =
false;
819 bool foundVisible =
false;
821 int removedItems = 0;
822 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
823 while (i < m_visibleItems.count()) {
824 ListItem *item = m_visibleItems[i];
825 const qreal pos = item->y() + m_clipItem->y();
827 if (pos + item->height() < bufferFrom || pos > bufferTo) {
830 m_visibleItems.removeAt(i);
836 const int itemIndex = m_firstVisibleIndex + removedItems + i;
837 m_firstVisibleIndex = itemIndex;
843 initializeValuesForEmptyList();
845 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
852 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
855 if (asynchronous && m_asyncRequestedIndex != -1)
858 m_asyncRequestedIndex = -1;
859 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
860 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
863 m_delegateModel->release(
object);
864 if (!m_delegateValidated) {
865 m_delegateValidated =
true;
866 QObject* delegateObj = delegate();
867 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
870 m_asyncRequestedIndex = modelIndex;
875 ListItem *listItem =
new ListItem;
876 listItem->m_item = item;
877 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
878 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
879 ListItem *prevItem = itemAtIndex(modelIndex - 1);
880 bool lostItem =
false;
884 listItem->setY(prevItem->y() + prevItem->height());
886 ListItem *currItem = itemAtIndex(modelIndex);
889 listItem->setY(currItem->y() - listItem->height());
891 ListItem *nextItem = itemAtIndex(modelIndex + 1);
893 listItem->setY(nextItem->y() - listItem->height());
894 }
else if (modelIndex == 0) {
895 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
896 }
else if (!m_visibleItems.isEmpty()) {
902 listItem->setCulled(
true);
903 releaseItem(listItem);
906 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
907 if (m_visibleItems.isEmpty()) {
908 m_visibleItems << listItem;
910 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
912 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
913 m_firstVisibleIndex = modelIndex;
916 if (listItem->sectionItem()) {
917 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
918 context->setContextProperty(QStringLiteral(
"delegateIndex"), modelIndex);
921 m_contentHeightDirty =
true;
927 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
929 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
931 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
938 if (!QQmlEngine::contextForObject(
this)->parentContext())
941 item->setParentItem(m_clipItem);
942 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
943 context->setContextProperty(QStringLiteral(
"ListViewWithPageHeader"),
this);
944 context->setContextProperty(QStringLiteral(
"heightToClip"), QVariant::fromValue<int>(0));
945 if (modelIndex == m_asyncRequestedIndex) {
946 createItem(modelIndex,
false);
951 void ListViewWithPageHeader::updateClipItem()
953 m_clipItem->setHeight(height() - m_headerItemShownHeight);
954 m_clipItem->setY(contentY() + m_headerItemShownHeight);
955 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
958 void ListViewWithPageHeader::onContentHeightChanged()
963 void ListViewWithPageHeader::onContentWidthChanged()
965 m_clipItem->setWidth(contentItem()->width());
968 void ListViewWithPageHeader::onHeightChanged()
974 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
978 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
980 Q_FOREACH(
const QQmlChangeSet::Change
remove, changeSet.removes()) {
982 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
983 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
986 bool growDown =
true;
987 for (
int i = 0; growDown && i <
remove.count; ++i) {
988 const int modelIndex =
remove.index + i;
989 ListItem *item = itemAtIndex(modelIndex);
990 if (item && !item->culled()) {
994 for (
int i =
remove.count - 1; i >= 0; --i) {
995 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
996 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
997 ListItem *item = m_visibleItems[visibleIndex];
999 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
1000 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
1001 if (!nextItem->sectionItem()) {
1002 nextItem->setSectionItem(item->sectionItem());
1003 item->setSectionItem(
nullptr);
1007 m_visibleItems.removeAt(visibleIndex);
1012 }
else if (
remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
1013 m_visibleItems.first()->setY(oldFirstValidIndexPos);
1015 if (m_visibleItems.isEmpty()) {
1016 m_firstVisibleIndex = -1;
1018 m_firstVisibleIndex -= qMax(0, m_firstVisibleIndex -
remove.index);
1020 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
1021 m_firstVisibleIndex -=
remove.count;
1023 for (
int i =
remove.count - 1; i >= 0; --i) {
1024 const int modelIndex =
remove.index + i;
1025 if (modelIndex == m_asyncRequestedIndex) {
1026 m_asyncRequestedIndex = -1;
1027 }
else if (modelIndex < m_asyncRequestedIndex) {
1028 m_asyncRequestedIndex--;
1033 Q_FOREACH(
const QQmlChangeSet::Change insert, changeSet.inserts()) {
1035 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
1036 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
1037 if (insertingInValidIndexes || firstItemWithViewOnTop)
1041 bool growUp =
false;
1042 if (!firstItemWithViewOnTop) {
1043 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1044 if (!m_visibleItems[i]->culled()) {
1045 if (insert.index <= m_firstVisibleIndex + i) {
1053 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1054 for (
int i = insert.count - 1; i >= 0; --i) {
1055 const int modelIndex = insert.index + i;
1056 ListItem *item = createItem(modelIndex,
false);
1058 ListItem *firstItem = m_visibleItems.first();
1059 firstItem->setY(firstItem->y() - item->height());
1063 if (m_sectionDelegate) {
1064 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1065 if (nextItem && !nextItem->sectionItem()) {
1066 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1067 if (growUp && nextItem->sectionItem()) {
1068 ListItem *firstItem = m_visibleItems.first();
1069 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1074 if (firstItemWithViewOnTop) {
1075 ListItem *firstItem = m_visibleItems.first();
1076 firstItem->setY(oldFirstValidIndexPos);
1079 }
else if (insert.index <= m_firstVisibleIndex) {
1080 m_firstVisibleIndex += insert.count;
1083 for (
int i = insert.count - 1; i >= 0; --i) {
1084 const int modelIndex = insert.index + i;
1085 if (modelIndex <= m_asyncRequestedIndex) {
1086 m_asyncRequestedIndex++;
1091 Q_FOREACH(
const QQmlChangeSet::Change change, changeSet.changes()) {
1092 for (
int i = change.start(); i < change.end(); ++i) {
1093 updateSectionItem(i);
1096 updateSectionItem(change.end());
1099 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1100 if (m_visibleItems.isEmpty()) {
1101 initializeValuesForEmptyList();
1107 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1108 ListItem *item = m_visibleItems[i];
1109 if (item->sectionItem()) {
1110 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1111 context->setContextProperty(QStringLiteral(
"delegateIndex"), m_firstVisibleIndex + i);
1117 m_contentHeightDirty =
true;
1120 void ListViewWithPageHeader::contentYAnimationRunningChanged(
bool running)
1122 setInteractive(!running);
1124 m_contentHeightDirty =
true;
1129 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * ,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1131 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1132 if (heightDiff != 0) {
1133 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1134 ListItem *firstItem = m_visibleItems.first();
1135 firstItem->setY(firstItem->y() - heightDiff);
1142 m_contentHeightDirty =
true;
1146 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1148 if (item == m_headerItem) {
1149 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1152 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1155 m_contentHeightDirty =
true;
1160 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1162 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1163 if (m_headerItemShownHeight > 0) {
1166 m_headerItemShownHeight += heightDiff;
1167 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1170 Q_EMIT headerItemShownHeightChanged();
1172 if (oldHeaderY + oldHeaderHeight > contentY()) {
1175 ListItem *firstItem = m_visibleItems.first();
1176 firstItem->setY(firstItem->y() + heightDiff);
1187 void ListViewWithPageHeader::adjustMinYExtent()
1189 if (m_visibleItems.isEmpty() || contentHeight() < height()) {
1192 qreal nonCreatedHeight = 0;
1193 if (m_firstVisibleIndex != 0) {
1195 const int visibleItems = m_visibleItems.count();
1196 qreal visibleItemsHeight = 0;
1197 Q_FOREACH(ListItem *item, m_visibleItems) {
1198 visibleItemsHeight += item->height();
1200 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1203 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1204 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1205 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1207 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1212 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const 1214 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1215 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1216 return m_visibleItems[visibleIndexedModelIndex];
1221 void ListViewWithPageHeader::layout()
1227 if (!m_visibleItems.isEmpty()) {
1228 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1229 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1231 qreal pos = m_visibleItems.first()->y();
1234 int firstReallyVisibleItem = -1;
1235 int modelIndex = m_firstVisibleIndex;
1236 Q_FOREACH(ListItem *item, m_visibleItems) {
1237 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1238 item->setCulled(cull);
1240 if (!cull && firstReallyVisibleItem == -1) {
1241 firstReallyVisibleItem = modelIndex;
1242 if (m_topSectionItem) {
1248 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1249 bool showStickySectionItem;
1254 if (topSectionStickPos > pos) {
1255 showStickySectionItem =
true;
1256 }
else if (topSectionStickPos == pos) {
1257 showStickySectionItem = !item->sectionItem();
1259 showStickySectionItem =
false;
1261 if (!showStickySectionItem) {
1262 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1263 if (item->sectionItem()) {
1268 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1272 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1273 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1274 context->setContextProperty(QStringLiteral(
"section"), section);
1276 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1277 m_topSectionItem->setY(topSectionStickPos);
1278 int delegateIndex = modelIndex;
1280 while (delegateIndex > 0) {
1281 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1282 if (prevSection != section)
1286 context->setContextProperty(QStringLiteral(
"delegateIndex"), delegateIndex);
1287 if (item->sectionItem()) {
1288 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1293 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1294 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1295 if (!cull && pos < clipFrom) {
1296 context->setContextProperty(QStringLiteral(
"heightToClip"), clipFrom - pos);
1298 context->setContextProperty(QStringLiteral(
"heightToClip"), QVariant::fromValue<int>(0));
1301 pos += item->height();
1307 if (m_topSectionItem) {
1308 if (firstReallyVisibleItem >= 0) {
1309 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1310 ListItem *item = m_visibleItems[i];
1311 if (item->sectionItem()) {
1312 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1313 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1324 void ListViewWithPageHeader::updatePolish()
1329 if (!QQmlEngine::contextForObject(
this)->parentContext())
1332 Q_FOREACH(ListItem *item, m_itemsToRelease)
1333 reallyReleaseItem(item);
1334 m_itemsToRelease.clear();
1343 if (m_contentHeightDirty) {
1344 qreal contentHeight;
1345 if (m_visibleItems.isEmpty()) {
1346 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1348 const int modelCount = model()->rowCount();
1349 const int visibleItems = m_visibleItems.count();
1350 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1351 qreal nonCreatedHeight = 0;
1352 if (lastValidIndex != modelCount - 1) {
1353 const int visibleItems = m_visibleItems.count();
1354 qreal visibleItemsHeight = 0;
1355 Q_FOREACH(ListItem *item, m_visibleItems) {
1356 visibleItemsHeight += item->height();
1358 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1359 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1361 ListItem *item = m_visibleItems.last();
1362 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1363 if (m_firstVisibleIndex != 0) {
1365 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1369 m_contentHeightDirty =
false;
1371 if (contentHeight < height()) {
1375 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1376 setContentHeight(contentHeight);
1377 m_inContentHeightKeepHeaderShown =
false;
1381 #include "moc_listviewwithpageheader.cpp"