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/qqmlcontext_p.h> 101 #include <private/qqmldelegatemodel_p.h> 102 #include <private/qqmlglobal_p.h> 103 #include <private/qquickitem_p.h> 104 #include <private/qquickanimation_p.h> 105 #pragma GCC diagnostic pop 108 qreal ListViewWithPageHeader::ListItem::height()
const 110 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
113 qreal ListViewWithPageHeader::ListItem::y()
const 115 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
118 void ListViewWithPageHeader::ListItem::setY(qreal newY)
121 m_sectionItem->setY(newY);
122 m_item->setY(newY + m_sectionItem->height());
128 bool ListViewWithPageHeader::ListItem::culled()
const 130 return QQuickItemPrivate::get(m_item)->culled;
133 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
135 QQuickItemPrivate::get(m_item)->setCulled(culled);
137 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
140 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
142 m_sectionItem = sectionItem;
145 ListViewWithPageHeader::ListViewWithPageHeader()
146 : m_delegateModel(nullptr)
147 , m_asyncRequestedIndex(-1)
148 , m_delegateValidated(false)
149 , m_firstVisibleIndex(-1)
151 , m_contentHeightDirty(false)
152 , m_headerItem(nullptr)
153 , m_previousContentY(0)
154 , m_headerItemShownHeight(0)
155 , m_sectionDelegate(nullptr)
156 , m_topSectionItem(nullptr)
157 , m_forceNoClip(false)
159 , 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(QStringLiteral(
"contentY"));
169 m_contentYAnimation->setDuration(200);
170 m_contentYAnimation->setTargetObject(
this);
172 connect(contentItem(), &QQuickItem::widthChanged,
this, &ListViewWithPageHeader::onContentWidthChanged);
173 connect(
this, &ListViewWithPageHeader::contentHeightChanged,
this, &ListViewWithPageHeader::onContentHeightChanged);
174 connect(
this, &ListViewWithPageHeader::heightChanged,
this, &ListViewWithPageHeader::onHeightChanged);
175 connect(m_contentYAnimation, &QQuickNumberAnimation::runningChanged,
this, &ListViewWithPageHeader::contentYAnimationRunningChanged);
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, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
197 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
198 connect(m_delegateModel, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
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 initializeValuesForEmptyList();
225 m_delegateModel->setDelegate(delegate);
227 Q_EMIT delegateChanged();
228 m_delegateValidated = false;
229 m_contentHeightDirty = true;
236 m_firstVisibleIndex = -1;
240 if (m_topSectionItem) {
241 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
245 QQuickItem *ListViewWithPageHeader::header()
const 250 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
252 if (m_headerItem != headerItem) {
253 qreal oldHeaderHeight = 0;
254 qreal oldHeaderY = 0;
256 oldHeaderHeight = m_headerItem->height();
257 oldHeaderY = m_headerItem->y();
258 m_headerItem->setParentItem(
nullptr);
260 m_headerItem = headerItem;
262 m_headerItem->setParentItem(contentItem());
263 m_headerItem->setZ(1);
264 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
265 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
267 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
268 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
269 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
271 m_contentHeightDirty =
true;
273 Q_EMIT headerChanged();
277 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const 279 return m_sectionDelegate;
282 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
284 if (delegate != m_sectionDelegate) {
287 m_sectionDelegate = delegate;
289 m_topSectionItem = getSectionItem(QString(),
false );
290 if (m_topSectionItem) {
291 m_topSectionItem->setZ(3);
292 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
293 connect(m_topSectionItem, &QQuickItem::heightChanged,
this, &ListViewWithPageHeader::stickyHeaderHeightChanged);
298 Q_EMIT sectionDelegateChanged();
299 Q_EMIT stickyHeaderHeightChanged();
303 QString ListViewWithPageHeader::sectionProperty()
const 305 return m_sectionProperty;
308 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
310 if (property != m_sectionProperty) {
311 m_sectionProperty = property;
313 updateWatchedRoles();
317 Q_EMIT sectionPropertyChanged();
321 bool ListViewWithPageHeader::forceNoClip()
const 323 return m_forceNoClip;
326 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
328 if (noClip != m_forceNoClip) {
329 m_forceNoClip = noClip;
331 Q_EMIT forceNoClipChanged();
335 int ListViewWithPageHeader::stickyHeaderHeight()
const 337 return m_topSectionItem ? m_topSectionItem->height() : 0;
340 qreal ListViewWithPageHeader::headerItemShownHeight()
const 342 return m_headerItemShownHeight;
345 int ListViewWithPageHeader::cacheBuffer()
const 347 return m_cacheBuffer;
350 void ListViewWithPageHeader::setCacheBuffer(
int cacheBuffer)
352 if (cacheBuffer < 0) {
353 qmlInfo(
this) <<
"Cannot set a negative cache buffer";
357 if (cacheBuffer != m_cacheBuffer) {
358 m_cacheBuffer = cacheBuffer;
359 Q_EMIT cacheBufferChanged();
364 void ListViewWithPageHeader::positionAtBeginning()
366 if (m_delegateModel->count() <= 0)
369 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
370 if (m_firstVisibleIndex != 0) {
374 Q_FOREACH(ListItem *item, m_visibleItems)
376 m_visibleItems.clear();
377 m_firstVisibleIndex = -1;
381 ListItem *item = createItem(0, false);
384 qreal pos = item->y() + item->height();
385 const qreal bufferTo = height() + m_cacheBuffer;
386 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
387 if (!(item = createItem(modelIndex,
false)))
389 pos += item->height();
393 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
395 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
401 m_headerItem->setY(-m_minYExtent);
405 static inline bool uFuzzyCompare(qreal r1, qreal r2)
407 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
410 void ListViewWithPageHeader::showHeader()
415 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
416 if (!uFuzzyCompare(to, contentY())) {
417 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
418 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
422 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
423 if (!m_visibleItems.isEmpty()) {
425 ListItem *firstItem = m_visibleItems.first();
426 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
429 Q_EMIT headerItemShownHeightChanged();
431 m_contentYAnimation->setTo(to);
432 contentYAnimationType = ContentYAnimationShowHeader;
433 m_contentYAnimation->start();
437 int ListViewWithPageHeader::firstCreatedIndex()
const 439 return m_firstVisibleIndex;
442 int ListViewWithPageHeader::createdItemCount()
const 444 return m_visibleItems.count();
447 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const 449 ListItem *item = itemAtIndex(modelIndex);
456 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
458 ListItem *listItem = itemAtIndex(modelIndex);
460 return maximizeVisibleArea(listItem, listItem->height());
466 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
471 ListItem *listItem = itemAtIndex(modelIndex);
473 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
479 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
483 const auto listItemY = m_clipItem->y() + listItem->y();
484 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
486 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
487 m_contentYAnimation->setTo(to);
488 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
489 m_contentYAnimation->start();
490 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
491 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
494 auto realVisibleListItemY = listItemY;
495 if (m_topSectionItem) {
499 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
500 if (topSectionShown && !listItem->sectionItem()) {
501 realVisibleListItemY -= m_topSectionItem->height();
504 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
505 m_contentYAnimation->setTo(to);
506 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
507 m_contentYAnimation->start();
514 qreal ListViewWithPageHeader::minYExtent()
const 520 qreal ListViewWithPageHeader::maxYExtent()
const 522 return height() - contentHeight();
525 void ListViewWithPageHeader::componentComplete()
528 m_delegateModel->componentComplete();
530 QQuickFlickable::componentComplete();
535 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
540 if (!QQmlEngine::contextForObject(
this)->parentContext())
543 QQuickFlickable::viewportMoved(orient);
545 const qreal diff = m_previousContentY - contentY();
547 m_previousContentY = contentY();
552 void ListViewWithPageHeader::adjustHeader(qreal diff)
554 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
556 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
557 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
558 m_headerItem->setHeight(m_headerItem->implicitHeight());
562 const bool scrolledUp = m_previousContentY > contentY();
563 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
564 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
565 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
567 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
568 m_headerItemShownHeight = 0;
569 m_headerItem->setY(-m_minYExtent);
570 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
571 if (maximizeVisibleAreaRunning && diff > 0) {
573 m_headerItemShownHeight -= diff;
575 m_headerItemShownHeight += diff;
577 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
578 m_headerItemShownHeight = 0;
580 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
582 if (m_headerItemShownHeight > 0) {
583 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
584 m_headerItem->setY(contentY());
585 m_headerItemShownHeight = m_headerItem->height();
587 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
590 m_headerItem->setY(-m_minYExtent);
593 Q_EMIT headerItemShownHeightChanged();
596 m_headerItem->setY(contentY());
597 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
602 if (!showHeaderAnimationRunning) {
603 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
608 if (!m_visibleItems.isEmpty()) {
610 ListItem *firstItem = m_visibleItems.first();
611 firstItem->setY(firstItem->y() + diff);
612 if (showHeaderAnimationRunning) {
618 void ListViewWithPageHeader::createDelegateModel()
620 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
621 connect(m_delegateModel, &QQmlDelegateModel::createdItem,
this, &ListViewWithPageHeader::itemCreated);
622 if (isComponentComplete())
623 m_delegateModel->componentComplete();
624 updateWatchedRoles();
627 void ListViewWithPageHeader::refill()
632 if (!isComponentComplete()) {
636 const qreal from = contentY();
637 const qreal to = from + height();
638 const qreal bufferFrom = from - m_cacheBuffer;
639 const qreal bufferTo = to + m_cacheBuffer;
641 bool added = addVisibleItems(from, to,
false);
642 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
643 added |= addVisibleItems(bufferFrom, bufferTo,
true);
645 if (added || removed) {
646 m_contentHeightDirty =
true;
650 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
655 if (m_delegateModel->count() == 0)
663 if (!m_visibleItems.isEmpty()) {
664 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
665 item = m_visibleItems.last();
666 pos = item->y() + item->height() + m_clipItem->y();
668 bool changed =
false;
670 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
672 if (!(item = createItem(modelIndex, asynchronous)))
674 pos += item->height();
681 if (!m_visibleItems.isEmpty()) {
682 modelIndex = m_firstVisibleIndex - 1;
683 item = m_visibleItems.first();
684 pos = item->y() + m_clipItem->y();
686 while (modelIndex >= 0 && pos > fillFrom) {
688 if (!(item = createItem(modelIndex, asynchronous)))
690 pos -= item->height();
698 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
700 QQuickItem *item = listItem->m_item;
701 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
702 if (flags & QQmlDelegateModel::Destroyed) {
703 item->setParentItem(
nullptr);
705 listItem->sectionItem()->deleteLater();
709 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
711 QQuickItemPrivate::get(listItem->m_item)->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
712 if (listItem->sectionItem()) {
713 QQuickItemPrivate::get(listItem->sectionItem())->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
715 m_itemsToRelease << listItem;
718 void ListViewWithPageHeader::updateWatchedRoles()
720 if (m_delegateModel) {
721 QList<QByteArray> roles;
722 if (!m_sectionProperty.isEmpty())
723 roles << m_sectionProperty.toUtf8();
724 m_delegateModel->setWatchedRoles(roles);
728 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
730 if (!m_sectionDelegate)
733 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
735 if (modelIndex > 0) {
736 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
737 if (section == prevSection)
740 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
742 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
743 if (section == nextSection) {
745 ListItem *nextItem = itemAtIndex(modelIndex);
747 QQuickItem *sectionItem = nextItem->sectionItem();
748 nextItem->setSectionItem(
nullptr);
754 return getSectionItem(section);
757 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText,
bool watchGeometry)
759 QQuickItem *sectionItem =
nullptr;
761 QQmlContext *creationContext = m_sectionDelegate->creationContext();
762 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
763 QObject *nobj = m_sectionDelegate->beginCreate(context);
765 QQml_setParent_noEvent(context, nobj);
766 sectionItem = qobject_cast<QQuickItem *>(nobj);
770 sectionItem->setProperty(
"text", sectionText);
771 sectionItem->setProperty(
"delegateIndex", -1);
772 sectionItem->setZ(2);
773 QQml_setParent_noEvent(sectionItem, m_clipItem);
774 sectionItem->setParentItem(m_clipItem);
779 m_sectionDelegate->completeCreate();
781 if (watchGeometry && sectionItem) {
782 QQuickItemPrivate::get(sectionItem)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
788 void ListViewWithPageHeader::updateSectionItem(
int modelIndex)
790 ListItem *item = itemAtIndex(modelIndex);
792 const QString sectionText = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
794 bool needSectionHeader =
true;
796 if (modelIndex > 0) {
797 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
798 if (sectionText == prevSection) {
799 needSectionHeader =
false;
803 if (needSectionHeader) {
804 if (!item->sectionItem()) {
805 item->setSectionItem(getSectionItem(sectionText));
807 item->sectionItem()->setProperty(
"text", sectionText);
810 if (item->sectionItem()) {
811 item->sectionItem()->deleteLater();
812 item->setSectionItem(
nullptr);
818 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
823 if (contentY() < -m_minYExtent) {
825 }
else if (contentY() + height() > contentHeight()) {
828 bool changed =
false;
830 bool foundVisible =
false;
832 int removedItems = 0;
833 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
834 while (i < m_visibleItems.count()) {
835 ListItem *item = m_visibleItems[i];
836 const qreal pos = item->y() + m_clipItem->y();
838 if (pos + item->height() < bufferFrom || pos > bufferTo) {
841 m_visibleItems.removeAt(i);
847 const int itemIndex = m_firstVisibleIndex + removedItems + i;
848 m_firstVisibleIndex = itemIndex;
854 initializeValuesForEmptyList();
856 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
863 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
866 if (asynchronous && m_asyncRequestedIndex != -1)
869 m_asyncRequestedIndex = -1;
870 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
871 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
874 m_delegateModel->release(
object);
875 if (!m_delegateValidated) {
876 m_delegateValidated =
true;
877 QObject* delegateObj = delegate();
878 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
881 m_asyncRequestedIndex = modelIndex;
886 ListItem *listItem =
new ListItem;
887 listItem->m_item = item;
888 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
889 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
890 ListItem *prevItem = itemAtIndex(modelIndex - 1);
891 bool lostItem =
false;
895 listItem->setY(prevItem->y() + prevItem->height());
897 ListItem *currItem = itemAtIndex(modelIndex);
900 listItem->setY(currItem->y() - listItem->height());
902 ListItem *nextItem = itemAtIndex(modelIndex + 1);
904 listItem->setY(nextItem->y() - listItem->height());
905 }
else if (modelIndex == 0) {
906 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
907 }
else if (!m_visibleItems.isEmpty()) {
913 listItem->setCulled(
true);
914 releaseItem(listItem);
917 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
918 if (m_visibleItems.isEmpty()) {
919 m_visibleItems << listItem;
921 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
923 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
924 m_firstVisibleIndex = modelIndex;
927 if (listItem->sectionItem()) {
928 listItem->sectionItem()->setProperty(
"delegateIndex", modelIndex);
931 m_contentHeightDirty =
true;
937 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
939 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
941 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
948 if (!QQmlEngine::contextForObject(
this)->parentContext())
951 item->setParentItem(m_clipItem);
953 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
954 QQmlContextPrivate::get(context)->data->refreshExpressions();
955 item->setProperty(
"heightToClip", QVariant::fromValue<int>(0));
956 if (modelIndex == m_asyncRequestedIndex) {
957 createItem(modelIndex,
false);
962 void ListViewWithPageHeader::updateClipItem()
964 m_clipItem->setHeight(height() - m_headerItemShownHeight);
965 m_clipItem->setY(contentY() + m_headerItemShownHeight);
966 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
969 void ListViewWithPageHeader::onContentHeightChanged()
974 void ListViewWithPageHeader::onContentWidthChanged()
976 m_clipItem->setWidth(contentItem()->width());
979 void ListViewWithPageHeader::onHeightChanged()
985 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
989 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
991 Q_FOREACH(
const QQmlChangeSet::Change
remove, changeSet.removes()) {
993 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
994 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
997 bool growDown =
true;
998 for (
int i = 0; growDown && i <
remove.count; ++i) {
999 const int modelIndex =
remove.index + i;
1000 ListItem *item = itemAtIndex(modelIndex);
1001 if (item && !item->culled()) {
1005 for (
int i =
remove.count - 1; i >= 0; --i) {
1006 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
1007 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
1008 ListItem *item = m_visibleItems[visibleIndex];
1010 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
1011 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
1012 if (!nextItem->sectionItem()) {
1013 nextItem->setSectionItem(item->sectionItem());
1014 item->setSectionItem(
nullptr);
1018 m_visibleItems.removeAt(visibleIndex);
1023 }
else if (
remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
1024 m_visibleItems.first()->setY(oldFirstValidIndexPos);
1026 if (m_visibleItems.isEmpty()) {
1027 m_firstVisibleIndex = -1;
1029 m_firstVisibleIndex -= qMax(0, m_firstVisibleIndex -
remove.index);
1031 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
1032 m_firstVisibleIndex -=
remove.count;
1034 for (
int i =
remove.count - 1; i >= 0; --i) {
1035 const int modelIndex =
remove.index + i;
1036 if (modelIndex == m_asyncRequestedIndex) {
1037 m_asyncRequestedIndex = -1;
1038 }
else if (modelIndex < m_asyncRequestedIndex) {
1039 m_asyncRequestedIndex--;
1044 Q_FOREACH(
const QQmlChangeSet::Change insert, changeSet.inserts()) {
1046 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
1047 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
1048 if (insertingInValidIndexes || firstItemWithViewOnTop)
1052 bool growUp =
false;
1053 if (!firstItemWithViewOnTop) {
1054 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1055 if (!m_visibleItems[i]->culled()) {
1056 if (insert.index <= m_firstVisibleIndex + i) {
1064 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1065 for (
int i = insert.count - 1; i >= 0; --i) {
1066 const int modelIndex = insert.index + i;
1067 ListItem *item = createItem(modelIndex,
false);
1069 ListItem *firstItem = m_visibleItems.first();
1070 firstItem->setY(firstItem->y() - item->height());
1074 if (m_sectionDelegate) {
1075 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1076 if (nextItem && !nextItem->sectionItem()) {
1077 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1078 if (growUp && nextItem->sectionItem()) {
1079 ListItem *firstItem = m_visibleItems.first();
1080 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1085 if (firstItemWithViewOnTop) {
1086 ListItem *firstItem = m_visibleItems.first();
1087 firstItem->setY(oldFirstValidIndexPos);
1090 }
else if (insert.index <= m_firstVisibleIndex) {
1091 m_firstVisibleIndex += insert.count;
1094 for (
int i = insert.count - 1; i >= 0; --i) {
1095 const int modelIndex = insert.index + i;
1096 if (modelIndex <= m_asyncRequestedIndex) {
1097 m_asyncRequestedIndex++;
1102 Q_FOREACH(
const QQmlChangeSet::Change change, changeSet.changes()) {
1103 for (
int i = change.start(); i < change.end(); ++i) {
1104 updateSectionItem(i);
1107 updateSectionItem(change.end());
1110 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1111 if (m_visibleItems.isEmpty()) {
1112 initializeValuesForEmptyList();
1118 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1119 ListItem *item = m_visibleItems[i];
1120 if (item->sectionItem()) {
1121 item->sectionItem()->setProperty(
"delegateIndex", m_firstVisibleIndex + i);
1127 m_contentHeightDirty =
true;
1130 void ListViewWithPageHeader::contentYAnimationRunningChanged(
bool running)
1132 setInteractive(!running);
1134 m_contentHeightDirty =
true;
1139 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem *item,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1141 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1142 if (heightDiff != 0) {
1143 if (!m_visibleItems.isEmpty()) {
1144 ListItem *firstItem = m_visibleItems.first();
1145 const auto prevFirstItemY = firstItem->y();
1146 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY()) {
1147 firstItem->setY(firstItem->y() - heightDiff);
1148 }
else if (item == firstItem->sectionItem()) {
1149 firstItem->setY(firstItem->y() + heightDiff);
1152 if (firstItem->y() != prevFirstItemY) {
1160 m_contentHeightDirty =
true;
1164 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1166 if (item == m_headerItem) {
1167 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1170 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1173 m_contentHeightDirty =
true;
1178 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1180 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1181 if (m_headerItemShownHeight > 0) {
1184 m_headerItemShownHeight += heightDiff;
1185 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1188 Q_EMIT headerItemShownHeightChanged();
1190 if (oldHeaderY + oldHeaderHeight > contentY()) {
1193 ListItem *firstItem = m_visibleItems.first();
1194 firstItem->setY(firstItem->y() + heightDiff);
1205 void ListViewWithPageHeader::adjustMinYExtent()
1207 if (m_visibleItems.isEmpty() || (contentHeight() + m_minYExtent < height())) {
1210 qreal nonCreatedHeight = 0;
1211 if (m_firstVisibleIndex != 0) {
1213 const int visibleItems = m_visibleItems.count();
1214 qreal visibleItemsHeight = 0;
1215 Q_FOREACH(ListItem *item, m_visibleItems) {
1216 visibleItemsHeight += item->height();
1218 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1221 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1222 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1223 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1225 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1230 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const 1232 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1233 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1234 return m_visibleItems[visibleIndexedModelIndex];
1239 void ListViewWithPageHeader::layout()
1245 if (!m_visibleItems.isEmpty()) {
1246 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1247 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1249 qreal pos = m_visibleItems.first()->y();
1252 int firstReallyVisibleItem = -1;
1253 int modelIndex = m_firstVisibleIndex;
1254 Q_FOREACH(ListItem *item, m_visibleItems) {
1255 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1256 item->setCulled(cull);
1258 if (!cull && firstReallyVisibleItem == -1) {
1259 firstReallyVisibleItem = modelIndex;
1260 if (m_topSectionItem) {
1266 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1267 bool showStickySectionItem;
1272 if (topSectionStickPos > pos) {
1273 showStickySectionItem =
true;
1274 }
else if (topSectionStickPos == pos) {
1275 showStickySectionItem = !item->sectionItem();
1277 showStickySectionItem =
false;
1279 if (!showStickySectionItem) {
1280 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1281 if (item->sectionItem()) {
1286 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1290 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1291 m_topSectionItem->setProperty(
"text", section);
1293 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1294 m_topSectionItem->setY(topSectionStickPos);
1295 int delegateIndex = modelIndex;
1297 while (delegateIndex > 0) {
1298 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1299 if (prevSection != section)
1303 m_topSectionItem->setProperty(
"delegateIndex", delegateIndex);
1304 if (item->sectionItem()) {
1305 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1310 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1311 if (!cull && pos < clipFrom) {
1312 item->m_item->setProperty(
"heightToClip", clipFrom - pos);
1314 item->m_item->setProperty(
"heightToClip", QVariant::fromValue<int>(0));
1317 pos += item->height();
1323 if (m_topSectionItem) {
1324 if (firstReallyVisibleItem >= 0) {
1325 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1326 ListItem *item = m_visibleItems[i];
1327 if (item->sectionItem()) {
1328 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1329 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1340 void ListViewWithPageHeader::updatePolish()
1345 if (!QQmlEngine::contextForObject(
this)->parentContext())
1348 Q_FOREACH(ListItem *item, m_itemsToRelease)
1349 reallyReleaseItem(item);
1350 m_itemsToRelease.clear();
1359 if (m_contentHeightDirty) {
1360 qreal contentHeight;
1361 if (m_visibleItems.isEmpty()) {
1362 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1364 const int modelCount = model()->rowCount();
1365 const int visibleItems = m_visibleItems.count();
1366 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1367 qreal nonCreatedHeight = 0;
1368 if (lastValidIndex != modelCount - 1) {
1369 const int visibleItems = m_visibleItems.count();
1370 qreal visibleItemsHeight = 0;
1371 Q_FOREACH(ListItem *item, m_visibleItems) {
1372 visibleItemsHeight += item->height();
1374 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1375 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1377 ListItem *item = m_visibleItems.last();
1378 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1379 if (m_firstVisibleIndex != 0) {
1381 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1385 m_contentHeightDirty =
false;
1387 if (contentHeight + m_minYExtent < height()) {
1391 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1392 setContentHeight(contentHeight);
1393 m_inContentHeightKeepHeaderShown =
false;
1397 #include "moc_listviewwithpageheader.cpp"