92 #include "listviewwithpageheader.h" 94 #include <QCoreApplication> 97 #include <qqmlengine.h> 98 #include <private/qqmlcontext_p.h> 99 #include <private/qqmldelegatemodel_p.h> 100 #include <private/qqmlglobal_p.h> 101 #include <private/qquickitem_p.h> 102 #include <private/qquickanimation_p.h> 105 qreal ListViewWithPageHeader::ListItem::height()
const 107 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
110 qreal ListViewWithPageHeader::ListItem::y()
const 112 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
115 void ListViewWithPageHeader::ListItem::setY(qreal newY)
118 m_sectionItem->setY(newY);
119 m_item->setY(newY + m_sectionItem->height());
125 bool ListViewWithPageHeader::ListItem::culled()
const 127 return QQuickItemPrivate::get(m_item)->culled;
130 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
132 QQuickItemPrivate::get(m_item)->setCulled(culled);
134 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
137 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
139 m_sectionItem = sectionItem;
142 ListViewWithPageHeader::ListViewWithPageHeader()
143 : m_delegateModel(nullptr)
144 , m_asyncRequestedIndex(-1)
145 , m_delegateValidated(false)
146 , m_firstVisibleIndex(-1)
148 , m_contentHeightDirty(false)
149 , m_headerItem(nullptr)
150 , m_previousContentY(0)
151 , m_headerItemShownHeight(0)
152 , m_sectionDelegate(nullptr)
153 , m_topSectionItem(nullptr)
154 , m_forceNoClip(false)
156 , m_inContentHeightKeepHeaderShown(false)
159 m_clipItem =
new QQuickItem(contentItem());
163 m_contentYAnimation =
new QQuickNumberAnimation(
this);
164 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
165 m_contentYAnimation->setProperty(QStringLiteral(
"contentY"));
166 m_contentYAnimation->setDuration(200);
167 m_contentYAnimation->setTargetObject(
this);
169 connect(contentItem(), &QQuickItem::widthChanged,
this, &ListViewWithPageHeader::onContentWidthChanged);
170 connect(
this, &ListViewWithPageHeader::contentHeightChanged,
this, &ListViewWithPageHeader::onContentHeightChanged);
171 connect(
this, &ListViewWithPageHeader::heightChanged,
this, &ListViewWithPageHeader::onHeightChanged);
172 connect(m_contentYAnimation, &QQuickNumberAnimation::runningChanged,
this, &ListViewWithPageHeader::contentYAnimationRunningChanged);
174 setFlickableDirection(VerticalFlick);
177 ListViewWithPageHeader::~ListViewWithPageHeader()
181 QAbstractItemModel *ListViewWithPageHeader::model()
const 183 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
186 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
188 if (model != this->model()) {
189 if (!m_delegateModel) {
190 createDelegateModel();
192 disconnect(m_delegateModel, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
194 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
195 connect(m_delegateModel, &QQmlDelegateModel::modelUpdated,
this, &ListViewWithPageHeader::onModelUpdated);
196 Q_EMIT modelChanged();
204 QQmlComponent *ListViewWithPageHeader::delegate()
const 206 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
209 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
211 if (delegate != this->delegate()) {
212 if (!m_delegateModel) {
213 createDelegateModel();
217 Q_FOREACH(ListItem *item, m_visibleItems)
219 m_visibleItems.clear();
220 initializeValuesForEmptyList();
222 m_delegateModel->setDelegate(delegate);
224 Q_EMIT delegateChanged();
225 m_delegateValidated =
false;
226 m_contentHeightDirty =
true;
231 void ListViewWithPageHeader::initializeValuesForEmptyList()
233 m_firstVisibleIndex = -1;
237 if (m_topSectionItem) {
238 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
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);
256 QQuickItemPrivate::get(m_headerItem)->removeItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
258 m_headerItem = headerItem;
260 m_headerItem->setParentItem(contentItem());
261 m_headerItem->setZ(1);
262 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
263 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
265 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
266 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
267 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
269 m_contentHeightDirty =
true;
271 Q_EMIT headerChanged();
275 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const 277 return m_sectionDelegate;
280 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
282 if (delegate != m_sectionDelegate) {
285 m_sectionDelegate = delegate;
287 m_topSectionItem = getSectionItem(QString(),
false );
288 if (m_topSectionItem) {
289 m_topSectionItem->setZ(3);
290 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
291 connect(m_topSectionItem, &QQuickItem::heightChanged,
this, &ListViewWithPageHeader::stickyHeaderHeightChanged);
296 Q_EMIT sectionDelegateChanged();
297 Q_EMIT stickyHeaderHeightChanged();
301 QString ListViewWithPageHeader::sectionProperty()
const 303 return m_sectionProperty;
306 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
308 if (property != m_sectionProperty) {
309 m_sectionProperty = property;
311 updateWatchedRoles();
315 Q_EMIT sectionPropertyChanged();
319 bool ListViewWithPageHeader::forceNoClip()
const 321 return m_forceNoClip;
324 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
326 if (noClip != m_forceNoClip) {
327 m_forceNoClip = noClip;
329 Q_EMIT forceNoClipChanged();
333 int ListViewWithPageHeader::stickyHeaderHeight()
const 335 return m_topSectionItem ? m_topSectionItem->height() : 0;
338 qreal ListViewWithPageHeader::headerItemShownHeight()
const 340 return m_headerItemShownHeight;
343 int ListViewWithPageHeader::cacheBuffer()
const 345 return m_cacheBuffer;
348 void ListViewWithPageHeader::setCacheBuffer(
int cacheBuffer)
350 if (cacheBuffer < 0) {
351 qmlInfo(
this) <<
"Cannot set a negative cache buffer";
355 if (cacheBuffer != m_cacheBuffer) {
356 m_cacheBuffer = cacheBuffer;
357 Q_EMIT cacheBufferChanged();
362 void ListViewWithPageHeader::positionAtBeginning()
364 if (m_delegateModel->count() <= 0)
367 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
368 if (m_firstVisibleIndex != 0) {
372 Q_FOREACH(ListItem *item, m_visibleItems)
374 m_visibleItems.clear();
375 m_firstVisibleIndex = -1;
379 ListItem *item = createItem(0,
false);
382 qreal pos = item->y() + item->height();
383 const qreal bufferTo = height() + m_cacheBuffer;
384 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
385 if (!(item = createItem(modelIndex,
false)))
387 pos += item->height();
391 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
393 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
399 m_headerItem->setY(-m_minYExtent);
403 static inline bool uFuzzyCompare(qreal r1, qreal r2)
405 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
408 void ListViewWithPageHeader::showHeader()
413 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
414 if (!uFuzzyCompare(to, contentY())) {
415 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
416 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
420 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
421 if (!m_visibleItems.isEmpty()) {
423 ListItem *firstItem = m_visibleItems.first();
424 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
427 Q_EMIT headerItemShownHeightChanged();
429 m_contentYAnimation->setTo(to);
430 contentYAnimationType = ContentYAnimationShowHeader;
431 m_contentYAnimation->start();
435 int ListViewWithPageHeader::firstCreatedIndex()
const 437 return m_firstVisibleIndex;
440 int ListViewWithPageHeader::createdItemCount()
const 442 return m_visibleItems.count();
445 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const 447 ListItem *item = itemAtIndex(modelIndex);
454 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
456 ListItem *listItem = itemAtIndex(modelIndex);
458 return maximizeVisibleArea(listItem, listItem->height());
464 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
469 ListItem *listItem = itemAtIndex(modelIndex);
471 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
477 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
481 const auto listItemY = m_clipItem->y() + listItem->y();
482 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
484 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
485 m_contentYAnimation->setTo(to);
486 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
487 m_contentYAnimation->start();
488 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
489 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
492 auto realVisibleListItemY = listItemY;
493 if (m_topSectionItem) {
497 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
498 if (topSectionShown && !listItem->sectionItem()) {
499 realVisibleListItemY -= m_topSectionItem->height();
502 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
503 m_contentYAnimation->setTo(to);
504 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
505 m_contentYAnimation->start();
512 qreal ListViewWithPageHeader::minYExtent()
const 518 qreal ListViewWithPageHeader::maxYExtent()
const 520 return height() - contentHeight();
523 void ListViewWithPageHeader::componentComplete()
526 m_delegateModel->componentComplete();
528 QQuickFlickable::componentComplete();
533 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
538 if (!QQmlEngine::contextForObject(
this)->parentContext())
541 QQuickFlickable::viewportMoved(orient);
543 const qreal diff = m_previousContentY - contentY();
545 m_previousContentY = contentY();
550 void ListViewWithPageHeader::adjustHeader(qreal diff)
552 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
554 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
555 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
556 m_headerItem->setHeight(m_headerItem->implicitHeight());
560 const bool scrolledUp = m_previousContentY > contentY();
561 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
562 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
563 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
565 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
566 m_headerItemShownHeight = 0;
567 m_headerItem->setY(-m_minYExtent);
568 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
569 if (maximizeVisibleAreaRunning && diff > 0) {
571 m_headerItemShownHeight -= diff;
573 m_headerItemShownHeight += diff;
575 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
576 m_headerItemShownHeight = 0;
578 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
580 if (m_headerItemShownHeight > 0) {
581 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
582 m_headerItem->setY(contentY());
583 m_headerItemShownHeight = m_headerItem->height();
585 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
588 m_headerItem->setY(-m_minYExtent);
590 }
else if (m_headerItemShownHeight == 0 && m_previousContentY > m_headerItem->y() && contentY() < m_headerItem->y()) {
593 m_headerItem->setY(-m_minYExtent);
595 Q_EMIT headerItemShownHeightChanged();
598 m_headerItem->setY(contentY());
599 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
604 if (!showHeaderAnimationRunning) {
605 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
610 if (!m_visibleItems.isEmpty()) {
612 ListItem *firstItem = m_visibleItems.first();
613 firstItem->setY(firstItem->y() + diff);
614 if (showHeaderAnimationRunning) {
620 void ListViewWithPageHeader::createDelegateModel()
622 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
623 connect(m_delegateModel, &QQmlDelegateModel::createdItem,
this, &ListViewWithPageHeader::itemCreated);
624 if (isComponentComplete())
625 m_delegateModel->componentComplete();
626 updateWatchedRoles();
629 void ListViewWithPageHeader::refill()
634 if (!isComponentComplete()) {
638 const qreal from = contentY();
639 const qreal to = from + height();
640 const qreal bufferFrom = from - m_cacheBuffer;
641 const qreal bufferTo = to + m_cacheBuffer;
643 bool added = addVisibleItems(from, to,
false);
644 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
645 added |= addVisibleItems(bufferFrom, bufferTo,
true);
647 if (added || removed) {
648 m_contentHeightDirty =
true;
652 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
657 if (m_delegateModel->count() == 0)
665 if (!m_visibleItems.isEmpty()) {
666 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
667 item = m_visibleItems.last();
668 pos = item->y() + item->height() + m_clipItem->y();
670 bool changed =
false;
672 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
674 if (!(item = createItem(modelIndex, asynchronous)))
676 pos += item->height();
683 if (!m_visibleItems.isEmpty()) {
684 modelIndex = m_firstVisibleIndex - 1;
685 item = m_visibleItems.first();
686 pos = item->y() + m_clipItem->y();
688 while (modelIndex >= 0 && pos > fillFrom) {
690 if (!(item = createItem(modelIndex, asynchronous)))
692 pos -= item->height();
700 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
702 QQuickItem *item = listItem->m_item;
703 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
704 if (flags & QQmlDelegateModel::Destroyed) {
705 item->setParentItem(
nullptr);
707 if (listItem->sectionItem()) {
708 listItem->sectionItem()->deleteLater();
713 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
715 QQuickItemPrivate::get(listItem->m_item)->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
716 if (listItem->sectionItem()) {
717 QQuickItemPrivate::get(listItem->sectionItem())->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
719 m_itemsToRelease << listItem;
722 void ListViewWithPageHeader::updateWatchedRoles()
724 if (m_delegateModel) {
725 QList<QByteArray> roles;
726 if (!m_sectionProperty.isEmpty())
727 roles << m_sectionProperty.toUtf8();
728 m_delegateModel->setWatchedRoles(roles);
732 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
734 if (!m_sectionDelegate)
737 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
739 if (modelIndex > 0) {
740 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
741 if (section == prevSection)
744 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
746 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
747 if (section == nextSection) {
749 ListItem *nextItem = itemAtIndex(modelIndex);
751 QQuickItem *sectionItem = nextItem->sectionItem();
752 nextItem->setSectionItem(
nullptr);
758 return getSectionItem(section);
761 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText,
bool watchGeometry)
763 QQuickItem *sectionItem =
nullptr;
765 QQmlContext *creationContext = m_sectionDelegate->creationContext();
766 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
767 QObject *nobj = m_sectionDelegate->beginCreate(context);
769 QQml_setParent_noEvent(context, nobj);
770 sectionItem = qobject_cast<QQuickItem *>(nobj);
774 sectionItem->setProperty(
"text", sectionText);
775 sectionItem->setProperty(
"delegate", QVariant());
776 sectionItem->setZ(2);
777 QQml_setParent_noEvent(sectionItem, m_clipItem);
778 sectionItem->setParentItem(m_clipItem);
783 m_sectionDelegate->completeCreate();
785 if (watchGeometry && sectionItem) {
786 QQuickItemPrivate::get(sectionItem)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
792 void ListViewWithPageHeader::updateSectionItem(
int modelIndex)
794 ListItem *item = itemAtIndex(modelIndex);
796 const QString sectionText = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
798 bool needSectionHeader =
true;
800 if (modelIndex > 0) {
801 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
802 if (sectionText == prevSection) {
803 needSectionHeader =
false;
807 if (needSectionHeader) {
808 if (!item->sectionItem()) {
809 item->setSectionItem(getSectionItem(sectionText));
811 item->sectionItem()->setProperty(
"text", sectionText);
814 if (item->sectionItem()) {
815 item->sectionItem()->deleteLater();
816 item->setSectionItem(
nullptr);
822 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
827 if (contentY() < -m_minYExtent) {
829 }
else if (contentY() + height() > contentHeight()) {
832 bool changed =
false;
834 bool foundVisible =
false;
836 int removedItems = 0;
837 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
838 while (i < m_visibleItems.count()) {
839 ListItem *item = m_visibleItems[i];
840 const qreal pos = item->y() + m_clipItem->y();
842 if (pos + item->height() < bufferFrom || pos > bufferTo) {
845 m_visibleItems.removeAt(i);
851 const int itemIndex = m_firstVisibleIndex + removedItems + i;
852 m_firstVisibleIndex = itemIndex;
858 initializeValuesForEmptyList();
860 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
867 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
870 if (asynchronous && m_asyncRequestedIndex != -1)
873 m_asyncRequestedIndex = -1;
874 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
875 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
878 m_delegateModel->release(
object);
879 if (!m_delegateValidated) {
880 m_delegateValidated =
true;
881 QObject* delegateObj = delegate();
882 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
885 m_asyncRequestedIndex = modelIndex;
890 ListItem *listItem =
new ListItem;
891 listItem->m_item = item;
892 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
893 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
894 ListItem *prevItem = itemAtIndex(modelIndex - 1);
895 bool lostItem =
false;
899 listItem->setY(prevItem->y() + prevItem->height());
901 ListItem *currItem = itemAtIndex(modelIndex);
904 listItem->setY(currItem->y() - listItem->height());
906 ListItem *nextItem = itemAtIndex(modelIndex + 1);
908 listItem->setY(nextItem->y() - listItem->height());
909 }
else if (modelIndex == 0) {
910 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
911 }
else if (!m_visibleItems.isEmpty()) {
917 listItem->setCulled(
true);
918 releaseItem(listItem);
921 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
922 if (m_visibleItems.isEmpty()) {
923 m_visibleItems << listItem;
925 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
927 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
928 m_firstVisibleIndex = modelIndex;
931 if (listItem->sectionItem()) {
932 listItem->sectionItem()->setProperty(
"delegate", QVariant::fromValue(listItem->m_item));
935 m_contentHeightDirty =
true;
941 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
943 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
945 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
952 if (!QQmlEngine::contextForObject(
this)->parentContext())
955 item->setParentItem(m_clipItem);
957 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
958 QQmlContextPrivate::get(context)->data->refreshExpressions();
959 item->setProperty(
"heightToClip", QVariant::fromValue<int>(0));
960 if (modelIndex == m_asyncRequestedIndex) {
961 createItem(modelIndex,
false);
966 void ListViewWithPageHeader::updateClipItem()
968 m_clipItem->setHeight(height() - m_headerItemShownHeight);
969 m_clipItem->setY(contentY() + m_headerItemShownHeight);
970 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
973 void ListViewWithPageHeader::onContentHeightChanged()
978 void ListViewWithPageHeader::onContentWidthChanged()
980 m_clipItem->setWidth(contentItem()->width());
983 void ListViewWithPageHeader::onHeightChanged()
985 m_clipItem->setHeight(height() - m_headerItemShownHeight);
990 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
994 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
996 Q_FOREACH(
const QQmlChangeSet::Change
remove, changeSet.removes()) {
998 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
999 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1002 bool growDown =
true;
1003 for (
int i = 0; growDown && i <
remove.count; ++i) {
1004 const int modelIndex =
remove.index + i;
1005 ListItem *item = itemAtIndex(modelIndex);
1006 if (item && !item->culled()) {
1010 for (
int i =
remove.count - 1; i >= 0; --i) {
1011 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
1012 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
1013 ListItem *item = m_visibleItems[visibleIndex];
1015 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
1016 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
1017 if (!nextItem->sectionItem()) {
1018 nextItem->setSectionItem(item->sectionItem());
1019 item->setSectionItem(
nullptr);
1023 m_visibleItems.removeAt(visibleIndex);
1028 }
else if (
remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
1029 m_visibleItems.first()->setY(oldFirstValidIndexPos);
1031 if (m_visibleItems.isEmpty()) {
1032 m_firstVisibleIndex = -1;
1034 m_firstVisibleIndex -= qMax(0, m_firstVisibleIndex -
remove.index);
1036 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
1037 m_firstVisibleIndex -=
remove.count;
1039 for (
int i =
remove.count - 1; i >= 0; --i) {
1040 const int modelIndex =
remove.index + i;
1041 if (modelIndex == m_asyncRequestedIndex) {
1042 m_asyncRequestedIndex = -1;
1043 }
else if (modelIndex < m_asyncRequestedIndex) {
1044 m_asyncRequestedIndex--;
1049 Q_FOREACH(
const QQmlChangeSet::Change insert, changeSet.inserts()) {
1051 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
1052 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
1053 if (insertingInValidIndexes || firstItemWithViewOnTop)
1057 bool growUp =
false;
1058 if (!firstItemWithViewOnTop) {
1059 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1060 if (!m_visibleItems[i]->culled()) {
1061 if (insert.index <= m_firstVisibleIndex + i) {
1069 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1070 for (
int i = insert.count - 1; i >= 0; --i) {
1071 const int modelIndex = insert.index + i;
1072 ListItem *item = createItem(modelIndex,
false);
1074 ListItem *firstItem = m_visibleItems.first();
1075 firstItem->setY(firstItem->y() - item->height());
1079 if (m_sectionDelegate) {
1080 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1081 if (nextItem && !nextItem->sectionItem()) {
1082 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1083 if (growUp && nextItem->sectionItem()) {
1084 ListItem *firstItem = m_visibleItems.first();
1085 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1090 if (firstItemWithViewOnTop) {
1091 ListItem *firstItem = m_visibleItems.first();
1092 firstItem->setY(oldFirstValidIndexPos);
1095 }
else if (insert.index <= m_firstVisibleIndex) {
1096 m_firstVisibleIndex += insert.count;
1099 for (
int i = insert.count - 1; i >= 0; --i) {
1100 const int modelIndex = insert.index + i;
1101 if (modelIndex <= m_asyncRequestedIndex) {
1102 m_asyncRequestedIndex++;
1107 Q_FOREACH(
const QQmlChangeSet::Change change, changeSet.changes()) {
1108 for (
int i = change.start(); i < change.end(); ++i) {
1109 updateSectionItem(i);
1112 updateSectionItem(change.end());
1115 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1116 if (m_visibleItems.isEmpty()) {
1117 initializeValuesForEmptyList();
1123 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1124 ListItem *item = m_visibleItems[i];
1125 if (item->sectionItem()) {
1126 item->sectionItem()->setProperty(
"delegate", QVariant::fromValue(item->m_item));
1132 m_contentHeightDirty =
true;
1135 void ListViewWithPageHeader::contentYAnimationRunningChanged(
bool running)
1137 setInteractive(!running);
1139 m_contentHeightDirty =
true;
1144 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem *item,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1146 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1147 if (heightDiff != 0) {
1148 if (!m_visibleItems.isEmpty()) {
1149 ListItem *firstItem = m_visibleItems.first();
1150 const auto prevFirstItemY = firstItem->y();
1151 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY()) {
1152 firstItem->setY(firstItem->y() - heightDiff);
1153 }
else if (item == firstItem->sectionItem()) {
1154 firstItem->setY(firstItem->y() + heightDiff);
1157 if (firstItem->y() != prevFirstItemY) {
1165 m_contentHeightDirty =
true;
1169 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1171 if (item == m_headerItem) {
1172 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1175 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1178 m_contentHeightDirty =
true;
1183 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1185 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1186 if (m_headerItemShownHeight > 0) {
1189 m_headerItemShownHeight += heightDiff;
1190 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1193 Q_EMIT headerItemShownHeightChanged();
1195 if (oldHeaderY + oldHeaderHeight > contentY()) {
1198 ListItem *firstItem = m_visibleItems.first();
1199 firstItem->setY(firstItem->y() + heightDiff);
1210 void ListViewWithPageHeader::adjustMinYExtent()
1212 if (m_visibleItems.isEmpty() || (contentHeight() + m_minYExtent < height())) {
1215 qreal nonCreatedHeight = 0;
1216 if (m_firstVisibleIndex != 0) {
1218 const int visibleItems = m_visibleItems.count();
1219 qreal visibleItemsHeight = 0;
1220 Q_FOREACH(ListItem *item, m_visibleItems) {
1221 visibleItemsHeight += item->height();
1223 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1226 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1227 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1228 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1230 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1235 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const 1237 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1238 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1239 return m_visibleItems[visibleIndexedModelIndex];
1244 void ListViewWithPageHeader::layout()
1250 if (!m_visibleItems.isEmpty()) {
1251 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1252 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1254 qreal pos = m_visibleItems.first()->y();
1257 int firstReallyVisibleItem = -1;
1258 int modelIndex = m_firstVisibleIndex;
1259 Q_FOREACH(ListItem *item, m_visibleItems) {
1260 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1261 item->setCulled(cull);
1263 if (!cull && firstReallyVisibleItem == -1) {
1264 firstReallyVisibleItem = modelIndex;
1265 if (m_topSectionItem) {
1271 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1272 bool showStickySectionItem;
1277 if (topSectionStickPos > pos) {
1278 showStickySectionItem =
true;
1279 }
else if (topSectionStickPos == pos) {
1280 showStickySectionItem = !item->sectionItem();
1282 showStickySectionItem =
false;
1284 if (!showStickySectionItem) {
1285 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1286 if (item->sectionItem()) {
1291 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1295 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1296 m_topSectionItem->setProperty(
"text", section);
1298 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1299 m_topSectionItem->setY(topSectionStickPos);
1300 m_topSectionItem->setProperty(
"delegate", QVariant::fromValue(item->m_item));
1301 if (item->sectionItem()) {
1302 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1307 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1308 if (!cull && pos < clipFrom) {
1309 item->m_item->setProperty(
"heightToClip", clipFrom - pos);
1311 item->m_item->setProperty(
"heightToClip", QVariant::fromValue<int>(0));
1314 pos += item->height();
1320 if (m_topSectionItem) {
1321 if (firstReallyVisibleItem >= 0) {
1322 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1323 ListItem *item = m_visibleItems[i];
1324 if (item->sectionItem()) {
1325 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1326 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1335 const bool cullHeader = m_headerItem->y() + m_headerItem->height() < contentY();
1336 QQuickItemPrivate::get(m_headerItem)->setCulled(cullHeader);
1341 void ListViewWithPageHeader::updatePolish()
1346 if (!QQmlEngine::contextForObject(
this)->parentContext())
1349 Q_FOREACH(ListItem *item, m_itemsToRelease)
1350 reallyReleaseItem(item);
1351 m_itemsToRelease.clear();
1360 if (m_contentHeightDirty) {
1361 qreal contentHeight;
1362 if (m_visibleItems.isEmpty()) {
1363 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1365 const int modelCount = model()->rowCount();
1366 const int visibleItems = m_visibleItems.count();
1367 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1368 qreal nonCreatedHeight = 0;
1369 if (lastValidIndex != modelCount - 1) {
1370 const int visibleItems = m_visibleItems.count();
1371 qreal visibleItemsHeight = 0;
1372 Q_FOREACH(ListItem *item, m_visibleItems) {
1373 visibleItemsHeight += item->height();
1375 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1376 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1378 ListItem *item = m_visibleItems.last();
1379 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1380 if (m_firstVisibleIndex != 0) {
1382 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1386 m_contentHeightDirty =
false;
1388 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1389 setContentHeight(contentHeight);
1390 m_inContentHeightKeepHeaderShown =
false;
1394 #include "moc_listviewwithpageheader.cpp"