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 static const qreal bufferRatio = 0.5;
109 qreal ListViewWithPageHeader::ListItem::height()
const
111 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
114 qreal ListViewWithPageHeader::ListItem::y()
const
116 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
119 void ListViewWithPageHeader::ListItem::setY(qreal newY)
122 m_sectionItem->setY(newY);
123 m_item->setY(newY + m_sectionItem->height());
129 bool ListViewWithPageHeader::ListItem::culled()
const
131 return QQuickItemPrivate::get(m_item)->culled;
134 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
136 QQuickItemPrivate::get(m_item)->setCulled(culled);
138 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
141 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
143 m_sectionItem = sectionItem;
144 QQmlContext *context = QQmlEngine::contextForObject(m_item)->parentContext();
145 context->setContextProperty(QLatin1String(
"hasSectionHeader"), QVariant::fromValue<bool>(sectionItem !=
nullptr));
148 ListViewWithPageHeader::ListViewWithPageHeader()
149 : m_delegateModel(nullptr)
150 , m_asyncRequestedIndex(-1)
151 , m_delegateValidated(false)
152 , m_firstVisibleIndex(-1)
154 , m_contentHeightDirty(false)
155 , m_headerItem(nullptr)
156 , m_previousContentY(0)
157 , m_headerItemShownHeight(0)
158 , m_sectionDelegate(nullptr)
159 , m_topSectionItem(nullptr)
160 , m_forceNoClip(false)
162 , m_inContentHeightKeepHeaderShown(false)
164 m_clipItem =
new QQuickItem(contentItem());
168 m_contentYAnimation =
new QQuickNumberAnimation(
this);
169 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
170 m_contentYAnimation->setProperty(
"contentY");
171 m_contentYAnimation->setDuration(200);
172 m_contentYAnimation->setTargetObject(
this);
174 connect(
this, SIGNAL(contentWidthChanged()),
this, SLOT(onContentWidthChanged()));
175 connect(
this, SIGNAL(contentHeightChanged()),
this, SLOT(onContentHeightChanged()));
176 connect(
this, SIGNAL(heightChanged()),
this, SLOT(onHeightChanged()));
177 connect(m_contentYAnimation, SIGNAL(stopped()),
this, SLOT(onShowHeaderAnimationFinished()));
179 setFlickableDirection(VerticalFlick);
182 ListViewWithPageHeader::~ListViewWithPageHeader()
186 QAbstractItemModel *ListViewWithPageHeader::model()
const
188 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
191 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
193 if (model != this->model()) {
194 if (!m_delegateModel) {
195 createDelegateModel();
197 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
199 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
200 connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
201 Q_EMIT modelChanged();
209 QQmlComponent *ListViewWithPageHeader::delegate()
const
211 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
214 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
216 if (delegate != this->delegate()) {
217 if (!m_delegateModel) {
218 createDelegateModel();
222 Q_FOREACH(ListItem *item, m_visibleItems)
224 m_visibleItems.clear();
225 m_firstVisibleIndex = -1;
229 if (m_topSectionItem) {
230 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
233 m_delegateModel->setDelegate(delegate);
235 Q_EMIT delegateChanged();
236 m_delegateValidated =
false;
237 m_contentHeightDirty =
true;
242 QQuickItem *ListViewWithPageHeader::header()
const
247 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
249 if (m_headerItem != headerItem) {
250 qreal oldHeaderHeight = 0;
251 qreal oldHeaderY = 0;
253 oldHeaderHeight = m_headerItem->height();
254 oldHeaderY = m_headerItem->y();
255 m_headerItem->setParentItem(
nullptr);
257 m_headerItem = headerItem;
259 m_headerItem->setParentItem(contentItem());
260 m_headerItem->setZ(1);
261 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
262 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
264 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
265 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
266 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
268 m_contentHeightDirty =
true;
270 Q_EMIT headerChanged();
274 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const
276 return m_sectionDelegate;
279 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
281 if (delegate != m_sectionDelegate) {
284 m_sectionDelegate = delegate;
286 m_topSectionItem = getSectionItem(QString());
287 m_topSectionItem->setZ(3);
288 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
289 connect(m_topSectionItem, SIGNAL(heightChanged()), SIGNAL(stickyHeaderHeightChanged()));
293 Q_EMIT sectionDelegateChanged();
294 Q_EMIT stickyHeaderHeightChanged();
298 QString ListViewWithPageHeader::sectionProperty()
const
300 return m_sectionProperty;
303 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
305 if (property != m_sectionProperty) {
306 m_sectionProperty = property;
308 updateWatchedRoles();
312 Q_EMIT sectionPropertyChanged();
316 bool ListViewWithPageHeader::forceNoClip()
const
318 return m_forceNoClip;
321 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
323 if (noClip != m_forceNoClip) {
324 m_forceNoClip = noClip;
326 Q_EMIT forceNoClipChanged();
330 int ListViewWithPageHeader::stickyHeaderHeight()
const
332 return m_topSectionItem ? m_topSectionItem->height() : 0;
335 void ListViewWithPageHeader::positionAtBeginning()
337 if (m_delegateModel->count() <= 0)
340 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
341 if (m_firstVisibleIndex != 0) {
345 Q_FOREACH(ListItem *item, m_visibleItems)
347 m_visibleItems.clear();
348 m_firstVisibleIndex = -1;
352 ListItem *item = createItem(0, false);
355 qreal pos = item->y() + item->height();
356 const qreal buffer = height() * bufferRatio;
357 const qreal bufferTo = height() + buffer;
358 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
359 if (!(item = createItem(modelIndex,
false)))
361 pos += item->height();
365 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
367 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
373 m_headerItem->setY(-m_minYExtent);
377 static inline bool uFuzzyCompare(qreal r1, qreal r2)
379 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
382 void ListViewWithPageHeader::showHeader()
387 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
388 if (!uFuzzyCompare(to, contentY())) {
389 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
390 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
394 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
395 if (!m_visibleItems.isEmpty()) {
397 ListItem *firstItem = m_visibleItems.first();
398 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
402 m_contentYAnimation->setTo(to);
403 contentYAnimationType = ContentYAnimationShowHeader;
404 m_contentYAnimation->start();
408 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const
410 ListItem *item = itemAtIndex(modelIndex);
417 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
419 ListItem *listItem = itemAtIndex(modelIndex);
421 return maximizeVisibleArea(listItem, listItem->height());
427 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
432 ListItem *listItem = itemAtIndex(modelIndex);
434 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
440 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
444 const auto listItemY = m_clipItem->y() + listItem->y();
445 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
447 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
448 m_contentYAnimation->setTo(to);
449 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
450 m_contentYAnimation->start();
451 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
452 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
455 auto realVisibleListItemY = listItemY;
456 if (m_topSectionItem) {
460 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
461 if (topSectionShown && !listItem->sectionItem()) {
462 realVisibleListItemY -= m_topSectionItem->height();
465 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
466 m_contentYAnimation->setTo(to);
467 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
468 m_contentYAnimation->start();
475 qreal ListViewWithPageHeader::minYExtent()
const
481 void ListViewWithPageHeader::componentComplete()
484 m_delegateModel->componentComplete();
486 QQuickFlickable::componentComplete();
491 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
496 if (!QQmlEngine::contextForObject(
this)->parentContext())
499 QQuickFlickable::viewportMoved(orient);
501 const qreal diff = m_previousContentY - contentY();
503 m_previousContentY = contentY();
508 void ListViewWithPageHeader::adjustHeader(qreal diff)
510 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
512 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
513 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
514 m_headerItem->setHeight(m_headerItem->implicitHeight());
518 const bool scrolledUp = m_previousContentY > contentY();
519 const bool notRebounding = contentY() + height() < contentHeight();
520 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
521 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
523 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
524 m_headerItemShownHeight = 0;
525 m_headerItem->setY(-m_minYExtent);
526 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
527 if (maximizeVisibleAreaRunning && diff > 0) {
529 m_headerItemShownHeight -= diff;
531 m_headerItemShownHeight += diff;
533 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
534 m_headerItemShownHeight = 0;
536 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
538 if (m_headerItemShownHeight > 0) {
539 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
540 m_headerItem->setY(contentY());
541 m_headerItemShownHeight = m_headerItem->height();
543 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
546 m_headerItem->setY(-m_minYExtent);
551 m_headerItem->setY(contentY());
552 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
557 if (!showHeaderAnimationRunning) {
558 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
563 if (!m_visibleItems.isEmpty()) {
565 ListItem *firstItem = m_visibleItems.first();
566 firstItem->setY(firstItem->y() + diff);
567 if (showHeaderAnimationRunning) {
573 void ListViewWithPageHeader::createDelegateModel()
575 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
576 connect(m_delegateModel, SIGNAL(createdItem(
int,QObject*)),
this, SLOT(itemCreated(
int,QObject*)));
577 if (isComponentComplete())
578 m_delegateModel->componentComplete();
579 updateWatchedRoles();
582 void ListViewWithPageHeader::refill()
587 if (!isComponentComplete()) {
591 const qreal buffer = height() * bufferRatio;
592 const qreal from = contentY();
593 const qreal to = from + height();
594 const qreal bufferFrom = from - buffer;
595 const qreal bufferTo = to + buffer;
597 bool added = addVisibleItems(from, to,
false);
598 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
599 added |= addVisibleItems(bufferFrom, bufferTo,
true);
601 if (added || removed) {
602 m_contentHeightDirty =
true;
606 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
611 if (m_delegateModel->count() == 0)
619 if (!m_visibleItems.isEmpty()) {
620 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
621 item = m_visibleItems.last();
622 pos = item->y() + item->height() + m_clipItem->y();
624 bool changed =
false;
626 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
628 if (!(item = createItem(modelIndex, asynchronous)))
630 pos += item->height();
637 if (!m_visibleItems.isEmpty()) {
638 modelIndex = m_firstVisibleIndex - 1;
639 item = m_visibleItems.first();
640 pos = item->y() + m_clipItem->y();
642 while (modelIndex >= 0 && pos > fillFrom) {
644 if (!(item = createItem(modelIndex, asynchronous)))
646 pos -= item->height();
654 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
656 QQuickItem *item = listItem->m_item;
657 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
658 if (flags & QQmlDelegateModel::Destroyed) {
659 item->setParentItem(
nullptr);
661 delete listItem->sectionItem();
665 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
667 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
668 itemPrivate->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
669 m_itemsToRelease << listItem;
672 void ListViewWithPageHeader::updateWatchedRoles()
674 if (m_delegateModel) {
675 QList<QByteArray> roles;
676 if (!m_sectionProperty.isEmpty())
677 roles << m_sectionProperty.toUtf8();
678 m_delegateModel->setWatchedRoles(roles);
682 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
684 if (!m_sectionDelegate)
687 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
688 if (section.isEmpty())
691 if (modelIndex > 0) {
692 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
693 if (section == prevSection)
696 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
698 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
699 if (section == nextSection) {
701 ListItem *nextItem = itemAtIndex(modelIndex);
703 QQuickItem *sectionItem = nextItem->sectionItem();
704 nextItem->setSectionItem(
nullptr);
710 return getSectionItem(section);
713 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText)
715 QQuickItem *sectionItem =
nullptr;
717 QQmlContext *creationContext = m_sectionDelegate->creationContext();
718 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
719 context->setContextProperty(QLatin1String(
"section"), sectionText);
720 context->setContextProperty(QLatin1String(
"delegateIndex"), -1);
721 QObject *nobj = m_sectionDelegate->beginCreate(context);
723 QQml_setParent_noEvent(context, nobj);
724 sectionItem = qobject_cast<QQuickItem *>(nobj);
728 sectionItem->setZ(2);
729 QQml_setParent_noEvent(sectionItem, m_clipItem);
730 sectionItem->setParentItem(m_clipItem);
735 m_sectionDelegate->completeCreate();
742 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
747 if (contentY() < -m_minYExtent) {
749 }
else if (contentY() + height() > contentHeight()) {
752 bool changed =
false;
754 bool foundVisible =
false;
756 int removedItems = 0;
757 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
758 while (i < m_visibleItems.count()) {
759 ListItem *item = m_visibleItems[i];
760 const qreal pos = item->y() + m_clipItem->y();
762 if (pos + item->height() < bufferFrom || pos > bufferTo) {
765 m_visibleItems.removeAt(i);
771 const int itemIndex = m_firstVisibleIndex + removedItems + i;
772 m_firstVisibleIndex = itemIndex;
778 m_firstVisibleIndex = -1;
780 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
787 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
790 if (asynchronous && m_asyncRequestedIndex != -1)
793 m_asyncRequestedIndex = -1;
794 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
795 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
798 m_delegateModel->release(
object);
799 if (!m_delegateValidated) {
800 m_delegateValidated =
true;
801 QObject* delegateObj = delegate();
802 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
805 m_asyncRequestedIndex = modelIndex;
810 ListItem *listItem =
new ListItem;
811 listItem->m_item = item;
812 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
813 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
814 ListItem *prevItem = itemAtIndex(modelIndex - 1);
815 bool lostItem =
false;
819 listItem->setY(prevItem->y() + prevItem->height());
821 ListItem *currItem = itemAtIndex(modelIndex);
824 listItem->setY(currItem->y() - listItem->height());
826 ListItem *nextItem = itemAtIndex(modelIndex + 1);
828 listItem->setY(nextItem->y() - listItem->height());
829 }
else if (modelIndex == 0 && m_headerItem) {
830 listItem->setY(m_headerItem->height());
831 }
else if (!m_visibleItems.isEmpty()) {
837 listItem->setCulled(
true);
838 releaseItem(listItem);
841 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
842 if (m_visibleItems.isEmpty()) {
843 m_visibleItems << listItem;
845 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
847 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
848 m_firstVisibleIndex = modelIndex;
851 if (listItem->sectionItem()) {
852 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
853 context->setContextProperty(QLatin1String(
"delegateIndex"), modelIndex);
856 m_contentHeightDirty =
true;
862 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
864 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
866 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
873 if (!QQmlEngine::contextForObject(
this)->parentContext())
876 item->setParentItem(m_clipItem);
877 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
878 context->setContextProperty(QLatin1String(
"ListViewWithPageHeader"),
this);
879 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
880 context->setContextProperty(QLatin1String(
"hasSectionHeader"), QVariant::fromValue<bool>(
false));
881 if (modelIndex == m_asyncRequestedIndex) {
882 createItem(modelIndex,
false);
887 void ListViewWithPageHeader::updateClipItem()
889 m_clipItem->setHeight(height() - m_headerItemShownHeight);
890 m_clipItem->setY(contentY() + m_headerItemShownHeight);
891 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
894 void ListViewWithPageHeader::onContentHeightChanged()
899 void ListViewWithPageHeader::onContentWidthChanged()
901 m_clipItem->setWidth(contentItem()->width());
904 void ListViewWithPageHeader::onHeightChanged()
910 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
914 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
916 Q_FOREACH(
const QQmlChangeSet::Remove &
remove, changeSet.removes()) {
918 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
919 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
922 bool growDown =
true;
923 for (
int i = 0; growDown && i <
remove.count; ++i) {
924 const int modelIndex =
remove.index + i;
925 ListItem *item = itemAtIndex(modelIndex);
926 if (item && !item->culled()) {
930 for (
int i =
remove.count - 1; i >= 0; --i) {
931 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
932 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
933 ListItem *item = m_visibleItems[visibleIndex];
935 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
936 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
937 if (!nextItem->sectionItem()) {
938 nextItem->setSectionItem(item->sectionItem());
939 item->setSectionItem(
nullptr);
943 m_visibleItems.removeAt(visibleIndex);
948 }
else if (
remove.index <= m_firstVisibleIndex) {
949 if (!m_visibleItems.isEmpty()) {
952 m_visibleItems.first()->setY(oldFirstValidIndexPos);
954 m_firstVisibleIndex = -1;
957 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
958 m_firstVisibleIndex -=
remove.count;
960 for (
int i =
remove.count - 1; i >= 0; --i) {
961 const int modelIndex =
remove.index + i;
962 if (modelIndex == m_asyncRequestedIndex) {
963 m_asyncRequestedIndex = -1;
964 }
else if (modelIndex < m_asyncRequestedIndex) {
965 m_asyncRequestedIndex--;
970 Q_FOREACH(
const QQmlChangeSet::Insert &insert, changeSet.inserts()) {
972 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
973 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
974 if (insertingInValidIndexes || firstItemWithViewOnTop)
979 if (!firstItemWithViewOnTop) {
980 for (
int i = 0; i < m_visibleItems.count(); ++i) {
981 if (!m_visibleItems[i]->culled()) {
982 if (insert.index <= m_firstVisibleIndex + i) {
990 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
991 for (
int i = insert.count - 1; i >= 0; --i) {
992 const int modelIndex = insert.index + i;
993 ListItem *item = createItem(modelIndex,
false);
995 ListItem *firstItem = m_visibleItems.first();
996 firstItem->setY(firstItem->y() - item->height());
1000 if (m_sectionDelegate) {
1001 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1002 if (nextItem && !nextItem->sectionItem()) {
1003 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1004 if (growUp && nextItem->sectionItem()) {
1005 ListItem *firstItem = m_visibleItems.first();
1006 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1011 if (firstItemWithViewOnTop) {
1012 ListItem *firstItem = m_visibleItems.first();
1013 firstItem->setY(oldFirstValidIndexPos);
1016 }
else if (insert.index <= m_firstVisibleIndex) {
1017 m_firstVisibleIndex += insert.count;
1020 for (
int i = insert.count - 1; i >= 0; --i) {
1021 const int modelIndex = insert.index + i;
1022 if (modelIndex <= m_asyncRequestedIndex) {
1023 m_asyncRequestedIndex++;
1028 Q_FOREACH(
const QQmlChangeSet::Change &change, changeSet.changes()) {
1030 for (
int i = change.index; i < change.count; ++i) {
1031 ListItem *item = itemAtIndex(i);
1032 if (item && item->sectionItem()) {
1033 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1034 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);
1035 context->setContextProperty(QLatin1String(
"section"), sectionText);
1040 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1044 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1045 ListItem *item = m_visibleItems[i];
1046 if (item->sectionItem()) {
1047 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1048 context->setContextProperty(QLatin1String(
"delegateIndex"), m_firstVisibleIndex + i);
1054 m_contentHeightDirty =
true;
1057 void ListViewWithPageHeader::onShowHeaderAnimationFinished()
1059 m_contentHeightDirty =
true;
1063 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * ,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1065 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1066 if (heightDiff != 0) {
1067 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1068 ListItem *firstItem = m_visibleItems.first();
1069 firstItem->setY(firstItem->y() - heightDiff);
1076 m_contentHeightDirty =
true;
1080 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1082 if (item == m_headerItem) {
1083 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1086 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1089 m_contentHeightDirty =
true;
1094 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1096 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1097 if (m_headerItemShownHeight > 0) {
1100 m_headerItemShownHeight += heightDiff;
1101 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1105 if (oldHeaderY + oldHeaderHeight > contentY()) {
1108 ListItem *firstItem = m_visibleItems.first();
1109 firstItem->setY(firstItem->y() + heightDiff);
1120 void ListViewWithPageHeader::adjustMinYExtent()
1122 if (m_visibleItems.isEmpty()) {
1125 qreal nonCreatedHeight = 0;
1126 if (m_firstVisibleIndex != 0) {
1128 const int visibleItems = m_visibleItems.count();
1129 qreal visibleItemsHeight = 0;
1130 Q_FOREACH(ListItem *item, m_visibleItems) {
1131 visibleItemsHeight += item->height();
1133 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1136 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1137 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1138 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1140 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1145 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const
1147 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1148 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1149 return m_visibleItems[visibleIndexedModelIndex];
1154 void ListViewWithPageHeader::layout()
1160 if (!m_visibleItems.isEmpty()) {
1161 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1162 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1164 qreal pos = m_visibleItems.first()->y();
1167 int firstReallyVisibleItem = -1;
1168 int modelIndex = m_firstVisibleIndex;
1169 Q_FOREACH(ListItem *item, m_visibleItems) {
1170 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1171 item->setCulled(cull);
1173 if (!cull && firstReallyVisibleItem == -1) {
1174 firstReallyVisibleItem = modelIndex;
1175 if (m_topSectionItem) {
1181 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1182 bool showStickySectionItem;
1187 if (topSectionStickPos > pos) {
1188 showStickySectionItem =
true;
1189 }
else if (topSectionStickPos == pos) {
1190 showStickySectionItem = !item->sectionItem();
1192 showStickySectionItem =
false;
1194 if (!showStickySectionItem) {
1195 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1196 if (item->sectionItem()) {
1201 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1205 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1206 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1207 context->setContextProperty(QLatin1String(
"section"), section);
1209 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1210 m_topSectionItem->setY(topSectionStickPos);
1211 int delegateIndex = modelIndex;
1213 while (delegateIndex > 0) {
1214 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1215 if (prevSection != section)
1219 context->setContextProperty(QLatin1String(
"delegateIndex"), delegateIndex);
1220 if (item->sectionItem()) {
1221 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1226 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1227 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1228 if (!cull && pos < clipFrom) {
1229 context->setContextProperty(QLatin1String(
"heightToClip"), clipFrom - pos);
1231 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
1234 pos += item->height();
1240 if (m_topSectionItem) {
1241 if (firstReallyVisibleItem >= 0) {
1242 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1243 ListItem *item = m_visibleItems[i];
1244 if (item->sectionItem()) {
1245 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1246 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1257 void ListViewWithPageHeader::updatePolish()
1262 if (!QQmlEngine::contextForObject(
this)->parentContext())
1265 Q_FOREACH(ListItem *item, m_itemsToRelease)
1266 reallyReleaseItem(item);
1267 m_itemsToRelease.clear();
1276 if (m_contentHeightDirty) {
1277 qreal contentHeight;
1278 if (m_visibleItems.isEmpty()) {
1279 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1281 const int modelCount = model()->rowCount();
1282 const int visibleItems = m_visibleItems.count();
1283 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1284 qreal nonCreatedHeight = 0;
1285 if (lastValidIndex != modelCount - 1) {
1286 const int visibleItems = m_visibleItems.count();
1287 qreal visibleItemsHeight = 0;
1288 Q_FOREACH(ListItem *item, m_visibleItems) {
1289 visibleItemsHeight += item->height();
1291 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1292 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1294 ListItem *item = m_visibleItems.last();
1295 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1296 if (m_firstVisibleIndex != 0) {
1298 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1302 m_contentHeightDirty =
false;
1304 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1305 setContentHeight(contentHeight);
1306 m_inContentHeightKeepHeaderShown =
false;
1310 #include "moc_listviewwithpageheader.cpp"