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;
146 ListViewWithPageHeader::ListViewWithPageHeader()
147 : m_delegateModel(nullptr)
148 , m_asyncRequestedIndex(-1)
149 , m_delegateValidated(false)
150 , m_firstVisibleIndex(-1)
152 , m_contentHeightDirty(false)
153 , m_headerItem(nullptr)
154 , m_previousContentY(0)
155 , m_headerItemShownHeight(0)
156 , m_sectionDelegate(nullptr)
157 , m_topSectionItem(nullptr)
158 , m_forceNoClip(false)
160 , m_inContentHeightKeepHeaderShown(false)
162 m_clipItem =
new QQuickItem(contentItem());
166 m_contentYAnimation =
new QQuickNumberAnimation(
this);
167 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
168 m_contentYAnimation->setProperty(
"contentY");
169 m_contentYAnimation->setDuration(200);
170 m_contentYAnimation->setTargetObject(
this);
172 connect(
this, SIGNAL(contentWidthChanged()),
this, SLOT(onContentWidthChanged()));
173 connect(
this, SIGNAL(contentHeightChanged()),
this, SLOT(onContentHeightChanged()));
174 connect(
this, SIGNAL(heightChanged()),
this, SLOT(onHeightChanged()));
175 connect(m_contentYAnimation, SIGNAL(runningChanged(
bool)),
this, SLOT(contentYAnimationRunningChanged(
bool)));
177 setFlickableDirection(VerticalFlick);
180 ListViewWithPageHeader::~ListViewWithPageHeader()
184 QAbstractItemModel *ListViewWithPageHeader::model()
const
186 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
189 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
191 if (model != this->model()) {
192 if (!m_delegateModel) {
193 createDelegateModel();
195 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
197 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
198 connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
199 Q_EMIT modelChanged();
207 QQmlComponent *ListViewWithPageHeader::delegate()
const
209 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
212 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
214 if (delegate != this->delegate()) {
215 if (!m_delegateModel) {
216 createDelegateModel();
220 Q_FOREACH(ListItem *item, m_visibleItems)
222 m_visibleItems.clear();
223 m_firstVisibleIndex = -1;
227 if (m_topSectionItem) {
228 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
231 m_delegateModel->setDelegate(delegate);
233 Q_EMIT delegateChanged();
234 m_delegateValidated =
false;
235 m_contentHeightDirty =
true;
240 QQuickItem *ListViewWithPageHeader::header()
const
245 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
247 if (m_headerItem != headerItem) {
248 qreal oldHeaderHeight = 0;
249 qreal oldHeaderY = 0;
251 oldHeaderHeight = m_headerItem->height();
252 oldHeaderY = m_headerItem->y();
253 m_headerItem->setParentItem(
nullptr);
255 m_headerItem = headerItem;
257 m_headerItem->setParentItem(contentItem());
258 m_headerItem->setZ(1);
259 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
260 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
262 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
263 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
264 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
266 m_contentHeightDirty =
true;
268 Q_EMIT headerChanged();
272 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const
274 return m_sectionDelegate;
277 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
279 if (delegate != m_sectionDelegate) {
282 m_sectionDelegate = delegate;
284 m_topSectionItem = getSectionItem(QString());
285 m_topSectionItem->setZ(3);
286 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
287 connect(m_topSectionItem, SIGNAL(heightChanged()), SIGNAL(stickyHeaderHeightChanged()));
291 Q_EMIT sectionDelegateChanged();
292 Q_EMIT stickyHeaderHeightChanged();
296 QString ListViewWithPageHeader::sectionProperty()
const
298 return m_sectionProperty;
301 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
303 if (property != m_sectionProperty) {
304 m_sectionProperty = property;
306 updateWatchedRoles();
310 Q_EMIT sectionPropertyChanged();
314 bool ListViewWithPageHeader::forceNoClip()
const
316 return m_forceNoClip;
319 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
321 if (noClip != m_forceNoClip) {
322 m_forceNoClip = noClip;
324 Q_EMIT forceNoClipChanged();
328 int ListViewWithPageHeader::stickyHeaderHeight()
const
330 return m_topSectionItem ? m_topSectionItem->height() : 0;
333 qreal ListViewWithPageHeader::headerItemShownHeight()
const
335 return m_headerItemShownHeight;
338 void ListViewWithPageHeader::positionAtBeginning()
340 if (m_delegateModel->count() <= 0)
343 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
344 if (m_firstVisibleIndex != 0) {
348 Q_FOREACH(ListItem *item, m_visibleItems)
350 m_visibleItems.clear();
351 m_firstVisibleIndex = -1;
355 ListItem *item = createItem(0, false);
358 qreal pos = item->y() + item->height();
359 const qreal buffer = height() * bufferRatio;
360 const qreal bufferTo = height() + buffer;
361 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
362 if (!(item = createItem(modelIndex,
false)))
364 pos += item->height();
368 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
370 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
376 m_headerItem->setY(-m_minYExtent);
380 static inline bool uFuzzyCompare(qreal r1, qreal r2)
382 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
385 void ListViewWithPageHeader::showHeader()
390 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
391 if (!uFuzzyCompare(to, contentY())) {
392 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
393 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
397 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
398 if (!m_visibleItems.isEmpty()) {
400 ListItem *firstItem = m_visibleItems.first();
401 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
404 Q_EMIT headerItemShownHeightChanged();
406 m_contentYAnimation->setTo(to);
407 contentYAnimationType = ContentYAnimationShowHeader;
408 m_contentYAnimation->start();
412 int ListViewWithPageHeader::firstCreatedIndex()
const
414 return m_firstVisibleIndex;
417 int ListViewWithPageHeader::createdItemCount()
const
419 return m_visibleItems.count();
422 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const
424 ListItem *item = itemAtIndex(modelIndex);
431 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
433 ListItem *listItem = itemAtIndex(modelIndex);
435 return maximizeVisibleArea(listItem, listItem->height());
441 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
446 ListItem *listItem = itemAtIndex(modelIndex);
448 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
454 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
458 const auto listItemY = m_clipItem->y() + listItem->y();
459 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
461 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
462 m_contentYAnimation->setTo(to);
463 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
464 m_contentYAnimation->start();
465 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
466 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
469 auto realVisibleListItemY = listItemY;
470 if (m_topSectionItem) {
474 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
475 if (topSectionShown && !listItem->sectionItem()) {
476 realVisibleListItemY -= m_topSectionItem->height();
479 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
480 m_contentYAnimation->setTo(to);
481 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
482 m_contentYAnimation->start();
489 qreal ListViewWithPageHeader::minYExtent()
const
495 void ListViewWithPageHeader::componentComplete()
498 m_delegateModel->componentComplete();
500 QQuickFlickable::componentComplete();
505 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
510 if (!QQmlEngine::contextForObject(
this)->parentContext())
513 QQuickFlickable::viewportMoved(orient);
515 const qreal diff = m_previousContentY - contentY();
517 m_previousContentY = contentY();
522 void ListViewWithPageHeader::adjustHeader(qreal diff)
524 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
526 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
527 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
528 m_headerItem->setHeight(m_headerItem->implicitHeight());
532 const bool scrolledUp = m_previousContentY > contentY();
533 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
534 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
535 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
537 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
538 m_headerItemShownHeight = 0;
539 m_headerItem->setY(-m_minYExtent);
540 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
541 if (maximizeVisibleAreaRunning && diff > 0) {
543 m_headerItemShownHeight -= diff;
545 m_headerItemShownHeight += diff;
547 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
548 m_headerItemShownHeight = 0;
550 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
552 if (m_headerItemShownHeight > 0) {
553 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
554 m_headerItem->setY(contentY());
555 m_headerItemShownHeight = m_headerItem->height();
557 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
560 m_headerItem->setY(-m_minYExtent);
563 Q_EMIT headerItemShownHeightChanged();
566 m_headerItem->setY(contentY());
567 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
572 if (!showHeaderAnimationRunning) {
573 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
578 if (!m_visibleItems.isEmpty()) {
580 ListItem *firstItem = m_visibleItems.first();
581 firstItem->setY(firstItem->y() + diff);
582 if (showHeaderAnimationRunning) {
588 void ListViewWithPageHeader::createDelegateModel()
590 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
591 connect(m_delegateModel, SIGNAL(createdItem(
int,QObject*)),
this, SLOT(itemCreated(
int,QObject*)));
592 if (isComponentComplete())
593 m_delegateModel->componentComplete();
594 updateWatchedRoles();
597 void ListViewWithPageHeader::refill()
602 if (!isComponentComplete()) {
606 const qreal buffer = height() * bufferRatio;
607 const qreal from = contentY();
608 const qreal to = from + height();
609 const qreal bufferFrom = from - buffer;
610 const qreal bufferTo = to + buffer;
612 bool added = addVisibleItems(from, to,
false);
613 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
614 added |= addVisibleItems(bufferFrom, bufferTo,
true);
616 if (added || removed) {
617 m_contentHeightDirty =
true;
621 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
626 if (m_delegateModel->count() == 0)
634 if (!m_visibleItems.isEmpty()) {
635 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
636 item = m_visibleItems.last();
637 pos = item->y() + item->height() + m_clipItem->y();
639 bool changed =
false;
641 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
643 if (!(item = createItem(modelIndex, asynchronous)))
645 pos += item->height();
652 if (!m_visibleItems.isEmpty()) {
653 modelIndex = m_firstVisibleIndex - 1;
654 item = m_visibleItems.first();
655 pos = item->y() + m_clipItem->y();
657 while (modelIndex >= 0 && pos > fillFrom) {
659 if (!(item = createItem(modelIndex, asynchronous)))
661 pos -= item->height();
669 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
671 QQuickItem *item = listItem->m_item;
672 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
673 if (flags & QQmlDelegateModel::Destroyed) {
674 item->setParentItem(
nullptr);
676 listItem->sectionItem()->deleteLater();
680 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
682 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
683 itemPrivate->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
684 m_itemsToRelease << listItem;
687 void ListViewWithPageHeader::updateWatchedRoles()
689 if (m_delegateModel) {
690 QList<QByteArray> roles;
691 if (!m_sectionProperty.isEmpty())
692 roles << m_sectionProperty.toUtf8();
693 m_delegateModel->setWatchedRoles(roles);
697 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
699 if (!m_sectionDelegate)
702 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
704 if (modelIndex > 0) {
705 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
706 if (section == prevSection)
709 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
711 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
712 if (section == nextSection) {
714 ListItem *nextItem = itemAtIndex(modelIndex);
716 QQuickItem *sectionItem = nextItem->sectionItem();
717 nextItem->setSectionItem(
nullptr);
723 return getSectionItem(section);
726 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText)
728 QQuickItem *sectionItem =
nullptr;
730 QQmlContext *creationContext = m_sectionDelegate->creationContext();
731 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
732 context->setContextProperty(QLatin1String(
"section"), sectionText);
733 context->setContextProperty(QLatin1String(
"delegateIndex"), -1);
734 QObject *nobj = m_sectionDelegate->beginCreate(context);
736 QQml_setParent_noEvent(context, nobj);
737 sectionItem = qobject_cast<QQuickItem *>(nobj);
741 sectionItem->setZ(2);
742 QQml_setParent_noEvent(sectionItem, m_clipItem);
743 sectionItem->setParentItem(m_clipItem);
748 m_sectionDelegate->completeCreate();
755 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
760 if (contentY() < -m_minYExtent) {
762 }
else if (contentY() + height() > contentHeight()) {
765 bool changed =
false;
767 bool foundVisible =
false;
769 int removedItems = 0;
770 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
771 while (i < m_visibleItems.count()) {
772 ListItem *item = m_visibleItems[i];
773 const qreal pos = item->y() + m_clipItem->y();
775 if (pos + item->height() < bufferFrom || pos > bufferTo) {
778 m_visibleItems.removeAt(i);
784 const int itemIndex = m_firstVisibleIndex + removedItems + i;
785 m_firstVisibleIndex = itemIndex;
791 m_firstVisibleIndex = -1;
793 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
800 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
803 if (asynchronous && m_asyncRequestedIndex != -1)
806 m_asyncRequestedIndex = -1;
807 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
808 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
811 m_delegateModel->release(
object);
812 if (!m_delegateValidated) {
813 m_delegateValidated =
true;
814 QObject* delegateObj = delegate();
815 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
818 m_asyncRequestedIndex = modelIndex;
823 ListItem *listItem =
new ListItem;
824 listItem->m_item = item;
825 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
826 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
827 ListItem *prevItem = itemAtIndex(modelIndex - 1);
828 bool lostItem =
false;
832 listItem->setY(prevItem->y() + prevItem->height());
834 ListItem *currItem = itemAtIndex(modelIndex);
837 listItem->setY(currItem->y() - listItem->height());
839 ListItem *nextItem = itemAtIndex(modelIndex + 1);
841 listItem->setY(nextItem->y() - listItem->height());
842 }
else if (modelIndex == 0) {
843 listItem->setY(m_headerItem ? m_headerItem->height() : 0);
844 }
else if (!m_visibleItems.isEmpty()) {
850 listItem->setCulled(
true);
851 releaseItem(listItem);
854 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
855 if (m_visibleItems.isEmpty()) {
856 m_visibleItems << listItem;
858 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
860 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
861 m_firstVisibleIndex = modelIndex;
864 if (listItem->sectionItem()) {
865 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
866 context->setContextProperty(QLatin1String(
"delegateIndex"), modelIndex);
869 m_contentHeightDirty =
true;
875 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
877 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
879 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
886 if (!QQmlEngine::contextForObject(
this)->parentContext())
889 item->setParentItem(m_clipItem);
890 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
891 context->setContextProperty(QLatin1String(
"ListViewWithPageHeader"),
this);
892 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
893 if (modelIndex == m_asyncRequestedIndex) {
894 createItem(modelIndex,
false);
899 void ListViewWithPageHeader::updateClipItem()
901 m_clipItem->setHeight(height() - m_headerItemShownHeight);
902 m_clipItem->setY(contentY() + m_headerItemShownHeight);
903 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
906 void ListViewWithPageHeader::onContentHeightChanged()
911 void ListViewWithPageHeader::onContentWidthChanged()
913 m_clipItem->setWidth(contentItem()->width());
916 void ListViewWithPageHeader::onHeightChanged()
922 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
926 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
928 Q_FOREACH(
const QQmlChangeSet::Remove &
remove, changeSet.removes()) {
930 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
931 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
934 bool growDown =
true;
935 for (
int i = 0; growDown && i <
remove.count; ++i) {
936 const int modelIndex =
remove.index + i;
937 ListItem *item = itemAtIndex(modelIndex);
938 if (item && !item->culled()) {
942 for (
int i =
remove.count - 1; i >= 0; --i) {
943 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
944 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
945 ListItem *item = m_visibleItems[visibleIndex];
947 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
948 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
949 if (!nextItem->sectionItem()) {
950 nextItem->setSectionItem(item->sectionItem());
951 item->setSectionItem(
nullptr);
955 m_visibleItems.removeAt(visibleIndex);
960 }
else if (
remove.index <= m_firstVisibleIndex) {
961 if (!m_visibleItems.isEmpty()) {
964 m_visibleItems.first()->setY(oldFirstValidIndexPos);
966 m_firstVisibleIndex = -1;
969 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
970 m_firstVisibleIndex -=
remove.count;
972 for (
int i =
remove.count - 1; i >= 0; --i) {
973 const int modelIndex =
remove.index + i;
974 if (modelIndex == m_asyncRequestedIndex) {
975 m_asyncRequestedIndex = -1;
976 }
else if (modelIndex < m_asyncRequestedIndex) {
977 m_asyncRequestedIndex--;
982 Q_FOREACH(
const QQmlChangeSet::Insert &insert, changeSet.inserts()) {
984 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
985 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
986 if (insertingInValidIndexes || firstItemWithViewOnTop)
991 if (!firstItemWithViewOnTop) {
992 for (
int i = 0; i < m_visibleItems.count(); ++i) {
993 if (!m_visibleItems[i]->culled()) {
994 if (insert.index <= m_firstVisibleIndex + i) {
1002 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1003 for (
int i = insert.count - 1; i >= 0; --i) {
1004 const int modelIndex = insert.index + i;
1005 ListItem *item = createItem(modelIndex,
false);
1007 ListItem *firstItem = m_visibleItems.first();
1008 firstItem->setY(firstItem->y() - item->height());
1012 if (m_sectionDelegate) {
1013 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1014 if (nextItem && !nextItem->sectionItem()) {
1015 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1016 if (growUp && nextItem->sectionItem()) {
1017 ListItem *firstItem = m_visibleItems.first();
1018 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1023 if (firstItemWithViewOnTop) {
1024 ListItem *firstItem = m_visibleItems.first();
1025 firstItem->setY(oldFirstValidIndexPos);
1028 }
else if (insert.index <= m_firstVisibleIndex) {
1029 m_firstVisibleIndex += insert.count;
1032 for (
int i = insert.count - 1; i >= 0; --i) {
1033 const int modelIndex = insert.index + i;
1034 if (modelIndex <= m_asyncRequestedIndex) {
1035 m_asyncRequestedIndex++;
1040 Q_FOREACH(
const QQmlChangeSet::Change &change, changeSet.changes()) {
1042 for (
int i = change.index; i < change.count; ++i) {
1043 ListItem *item = itemAtIndex(i);
1044 if (item && item->sectionItem()) {
1045 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1046 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);
1047 context->setContextProperty(QLatin1String(
"section"), sectionText);
1052 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1056 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1057 ListItem *item = m_visibleItems[i];
1058 if (item->sectionItem()) {
1059 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1060 context->setContextProperty(QLatin1String(
"delegateIndex"), m_firstVisibleIndex + i);
1066 m_contentHeightDirty =
true;
1069 void ListViewWithPageHeader::contentYAnimationRunningChanged(
bool running)
1071 setInteractive(!running);
1073 m_contentHeightDirty =
true;
1078 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * ,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1080 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1081 if (heightDiff != 0) {
1082 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1083 ListItem *firstItem = m_visibleItems.first();
1084 firstItem->setY(firstItem->y() - heightDiff);
1091 m_contentHeightDirty =
true;
1095 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1097 if (item == m_headerItem) {
1098 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1101 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1104 m_contentHeightDirty =
true;
1109 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1111 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1112 if (m_headerItemShownHeight > 0) {
1115 m_headerItemShownHeight += heightDiff;
1116 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1119 Q_EMIT headerItemShownHeightChanged();
1121 if (oldHeaderY + oldHeaderHeight > contentY()) {
1124 ListItem *firstItem = m_visibleItems.first();
1125 firstItem->setY(firstItem->y() + heightDiff);
1136 void ListViewWithPageHeader::adjustMinYExtent()
1138 if (m_visibleItems.isEmpty()) {
1141 qreal nonCreatedHeight = 0;
1142 if (m_firstVisibleIndex != 0) {
1144 const int visibleItems = m_visibleItems.count();
1145 qreal visibleItemsHeight = 0;
1146 Q_FOREACH(ListItem *item, m_visibleItems) {
1147 visibleItemsHeight += item->height();
1149 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1152 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1153 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1154 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1156 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1161 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const
1163 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1164 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1165 return m_visibleItems[visibleIndexedModelIndex];
1170 void ListViewWithPageHeader::layout()
1176 if (!m_visibleItems.isEmpty()) {
1177 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1178 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1180 qreal pos = m_visibleItems.first()->y();
1183 int firstReallyVisibleItem = -1;
1184 int modelIndex = m_firstVisibleIndex;
1185 Q_FOREACH(ListItem *item, m_visibleItems) {
1186 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1187 item->setCulled(cull);
1189 if (!cull && firstReallyVisibleItem == -1) {
1190 firstReallyVisibleItem = modelIndex;
1191 if (m_topSectionItem) {
1197 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1198 bool showStickySectionItem;
1203 if (topSectionStickPos > pos) {
1204 showStickySectionItem =
true;
1205 }
else if (topSectionStickPos == pos) {
1206 showStickySectionItem = !item->sectionItem();
1208 showStickySectionItem =
false;
1210 if (!showStickySectionItem) {
1211 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1212 if (item->sectionItem()) {
1217 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1221 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1222 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1223 context->setContextProperty(QLatin1String(
"section"), section);
1225 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1226 m_topSectionItem->setY(topSectionStickPos);
1227 int delegateIndex = modelIndex;
1229 while (delegateIndex > 0) {
1230 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1231 if (prevSection != section)
1235 context->setContextProperty(QLatin1String(
"delegateIndex"), delegateIndex);
1236 if (item->sectionItem()) {
1237 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1242 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1243 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1244 if (!cull && pos < clipFrom) {
1245 context->setContextProperty(QLatin1String(
"heightToClip"), clipFrom - pos);
1247 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
1250 pos += item->height();
1256 if (m_topSectionItem) {
1257 if (firstReallyVisibleItem >= 0) {
1258 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1259 ListItem *item = m_visibleItems[i];
1260 if (item->sectionItem()) {
1261 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1262 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1273 void ListViewWithPageHeader::updatePolish()
1278 if (!QQmlEngine::contextForObject(
this)->parentContext())
1281 Q_FOREACH(ListItem *item, m_itemsToRelease)
1282 reallyReleaseItem(item);
1283 m_itemsToRelease.clear();
1292 if (m_contentHeightDirty) {
1293 qreal contentHeight;
1294 if (m_visibleItems.isEmpty()) {
1295 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1297 const int modelCount = model()->rowCount();
1298 const int visibleItems = m_visibleItems.count();
1299 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1300 qreal nonCreatedHeight = 0;
1301 if (lastValidIndex != modelCount - 1) {
1302 const int visibleItems = m_visibleItems.count();
1303 qreal visibleItemsHeight = 0;
1304 Q_FOREACH(ListItem *item, m_visibleItems) {
1305 visibleItemsHeight += item->height();
1307 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1308 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1310 ListItem *item = m_visibleItems.last();
1311 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1312 if (m_firstVisibleIndex != 0) {
1314 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1318 m_contentHeightDirty =
false;
1320 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1321 setContentHeight(contentHeight);
1322 m_inContentHeightKeepHeaderShown =
false;
1326 #include "moc_listviewwithpageheader.cpp"