92 #include "listviewwithpageheader.h"
94 #include <QCoreApplication>
97 #include <qqmlengine.h>
98 #pragma GCC diagnostic push
99 #pragma GCC diagnostic ignored "-pedantic"
100 #include <private/qqmldelegatemodel_p.h>
101 #include <private/qqmlglobal_p.h>
102 #include <private/qquickitem_p.h>
103 #include <private/qquickanimation_p.h>
104 #pragma GCC diagnostic pop
107 qreal ListViewWithPageHeader::ListItem::height()
const
109 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
112 qreal ListViewWithPageHeader::ListItem::y()
const
114 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
117 void ListViewWithPageHeader::ListItem::setY(qreal newY)
120 m_sectionItem->setY(newY);
121 m_item->setY(newY + m_sectionItem->height());
127 bool ListViewWithPageHeader::ListItem::culled()
const
129 return QQuickItemPrivate::get(m_item)->culled;
132 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
134 QQuickItemPrivate::get(m_item)->setCulled(culled);
136 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
139 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
141 m_sectionItem = sectionItem;
144 ListViewWithPageHeader::ListViewWithPageHeader()
145 : m_delegateModel(nullptr)
146 , m_asyncRequestedIndex(-1)
147 , m_delegateValidated(false)
148 , m_firstVisibleIndex(-1)
150 , m_contentHeightDirty(false)
151 , m_headerItem(nullptr)
152 , m_previousContentY(0)
153 , m_headerItemShownHeight(0)
154 , m_sectionDelegate(nullptr)
155 , m_topSectionItem(nullptr)
156 , m_forceNoClip(false)
158 , m_inContentHeightKeepHeaderShown(false)
161 m_clipItem =
new QQuickItem(contentItem());
165 m_contentYAnimation =
new QQuickNumberAnimation(
this);
166 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
167 m_contentYAnimation->setProperty(
"contentY");
168 m_contentYAnimation->setDuration(200);
169 m_contentYAnimation->setTargetObject(
this);
171 connect(
this, SIGNAL(contentWidthChanged()),
this, SLOT(onContentWidthChanged()));
172 connect(
this, SIGNAL(contentHeightChanged()),
this, SLOT(onContentHeightChanged()));
173 connect(
this, SIGNAL(heightChanged()),
this, SLOT(onHeightChanged()));
174 connect(m_contentYAnimation, SIGNAL(runningChanged(
bool)),
this, SLOT(contentYAnimationRunningChanged(
bool)));
176 setFlickableDirection(VerticalFlick);
179 ListViewWithPageHeader::~ListViewWithPageHeader()
183 QAbstractItemModel *ListViewWithPageHeader::model()
const
185 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
188 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
190 if (model != this->model()) {
191 if (!m_delegateModel) {
192 createDelegateModel();
194 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
196 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
197 connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
198 Q_EMIT modelChanged();
206 QQmlComponent *ListViewWithPageHeader::delegate()
const
208 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
211 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
213 if (delegate != this->delegate()) {
214 if (!m_delegateModel) {
215 createDelegateModel();
219 Q_FOREACH(ListItem *item, m_visibleItems)
221 m_visibleItems.clear();
222 m_firstVisibleIndex = -1;
226 if (m_topSectionItem) {
227 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
230 m_delegateModel->setDelegate(delegate);
232 Q_EMIT delegateChanged();
233 m_delegateValidated =
false;
234 m_contentHeightDirty =
true;
239 QQuickItem *ListViewWithPageHeader::header()
const
244 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
246 if (m_headerItem != headerItem) {
247 qreal oldHeaderHeight = 0;
248 qreal oldHeaderY = 0;
250 oldHeaderHeight = m_headerItem->height();
251 oldHeaderY = m_headerItem->y();
252 m_headerItem->setParentItem(
nullptr);
254 m_headerItem = headerItem;
256 m_headerItem->setParentItem(contentItem());
257 m_headerItem->setZ(1);
258 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
259 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(
this, QQuickItemPrivate::ImplicitHeight);
261 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
262 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
263 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
265 m_contentHeightDirty =
true;
267 Q_EMIT headerChanged();
271 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const
273 return m_sectionDelegate;
276 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
278 if (delegate != m_sectionDelegate) {
281 m_sectionDelegate = delegate;
283 m_topSectionItem = getSectionItem(QString());
284 m_topSectionItem->setZ(3);
285 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
286 connect(m_topSectionItem, SIGNAL(heightChanged()), SIGNAL(stickyHeaderHeightChanged()));
290 Q_EMIT sectionDelegateChanged();
291 Q_EMIT stickyHeaderHeightChanged();
295 QString ListViewWithPageHeader::sectionProperty()
const
297 return m_sectionProperty;
300 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
302 if (property != m_sectionProperty) {
303 m_sectionProperty = property;
305 updateWatchedRoles();
309 Q_EMIT sectionPropertyChanged();
313 bool ListViewWithPageHeader::forceNoClip()
const
315 return m_forceNoClip;
318 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
320 if (noClip != m_forceNoClip) {
321 m_forceNoClip = noClip;
323 Q_EMIT forceNoClipChanged();
327 int ListViewWithPageHeader::stickyHeaderHeight()
const
329 return m_topSectionItem ? m_topSectionItem->height() : 0;
332 qreal ListViewWithPageHeader::headerItemShownHeight()
const
334 return m_headerItemShownHeight;
337 qreal ListViewWithPageHeader::cacheBuffer()
const
339 return m_cacheBuffer;
342 void ListViewWithPageHeader::setCacheBuffer(qreal cacheBuffer)
344 if (cacheBuffer != m_cacheBuffer) {
345 m_cacheBuffer = cacheBuffer;
346 Q_EMIT cacheBufferChanged();
351 void ListViewWithPageHeader::positionAtBeginning()
353 if (m_delegateModel->count() <= 0)
356 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
357 if (m_firstVisibleIndex != 0) {
361 Q_FOREACH(ListItem *item, m_visibleItems)
363 m_visibleItems.clear();
364 m_firstVisibleIndex = -1;
368 ListItem *item = createItem(0, false);
371 qreal pos = item->y() + item->height();
372 const qreal bufferTo = height() + m_cacheBuffer;
373 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
374 if (!(item = createItem(modelIndex,
false)))
376 pos += item->height();
380 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
382 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
388 m_headerItem->setY(-m_minYExtent);
392 static inline bool uFuzzyCompare(qreal r1, qreal r2)
394 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
397 void ListViewWithPageHeader::showHeader()
402 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
403 if (!uFuzzyCompare(to, contentY())) {
404 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
405 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
409 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
410 if (!m_visibleItems.isEmpty()) {
412 ListItem *firstItem = m_visibleItems.first();
413 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
416 Q_EMIT headerItemShownHeightChanged();
418 m_contentYAnimation->setTo(to);
419 contentYAnimationType = ContentYAnimationShowHeader;
420 m_contentYAnimation->start();
424 int ListViewWithPageHeader::firstCreatedIndex()
const
426 return m_firstVisibleIndex;
429 int ListViewWithPageHeader::createdItemCount()
const
431 return m_visibleItems.count();
434 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const
436 ListItem *item = itemAtIndex(modelIndex);
443 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
445 ListItem *listItem = itemAtIndex(modelIndex);
447 return maximizeVisibleArea(listItem, listItem->height());
453 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
458 ListItem *listItem = itemAtIndex(modelIndex);
460 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
466 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
470 const auto listItemY = m_clipItem->y() + listItem->y();
471 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
473 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
474 m_contentYAnimation->setTo(to);
475 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
476 m_contentYAnimation->start();
477 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
478 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
481 auto realVisibleListItemY = listItemY;
482 if (m_topSectionItem) {
486 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
487 if (topSectionShown && !listItem->sectionItem()) {
488 realVisibleListItemY -= m_topSectionItem->height();
491 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
492 m_contentYAnimation->setTo(to);
493 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
494 m_contentYAnimation->start();
501 qreal ListViewWithPageHeader::minYExtent()
const
507 void ListViewWithPageHeader::componentComplete()
510 m_delegateModel->componentComplete();
512 QQuickFlickable::componentComplete();
517 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
522 if (!QQmlEngine::contextForObject(
this)->parentContext())
525 QQuickFlickable::viewportMoved(orient);
527 const qreal diff = m_previousContentY - contentY();
529 m_previousContentY = contentY();
534 void ListViewWithPageHeader::adjustHeader(qreal diff)
536 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
538 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
539 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
540 m_headerItem->setHeight(m_headerItem->implicitHeight());
544 const bool scrolledUp = m_previousContentY > contentY();
545 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
546 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
547 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
549 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
550 m_headerItemShownHeight = 0;
551 m_headerItem->setY(-m_minYExtent);
552 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
553 if (maximizeVisibleAreaRunning && diff > 0) {
555 m_headerItemShownHeight -= diff;
557 m_headerItemShownHeight += diff;
559 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
560 m_headerItemShownHeight = 0;
562 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
564 if (m_headerItemShownHeight > 0) {
565 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
566 m_headerItem->setY(contentY());
567 m_headerItemShownHeight = m_headerItem->height();
569 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
572 m_headerItem->setY(-m_minYExtent);
575 Q_EMIT headerItemShownHeightChanged();
578 m_headerItem->setY(contentY());
579 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
584 if (!showHeaderAnimationRunning) {
585 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
590 if (!m_visibleItems.isEmpty()) {
592 ListItem *firstItem = m_visibleItems.first();
593 firstItem->setY(firstItem->y() + diff);
594 if (showHeaderAnimationRunning) {
600 void ListViewWithPageHeader::createDelegateModel()
602 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
603 connect(m_delegateModel, SIGNAL(createdItem(
int,QObject*)),
this, SLOT(itemCreated(
int,QObject*)));
604 if (isComponentComplete())
605 m_delegateModel->componentComplete();
606 updateWatchedRoles();
609 void ListViewWithPageHeader::refill()
614 if (!isComponentComplete()) {
618 const qreal from = contentY();
619 const qreal to = from + height();
620 const qreal bufferFrom = from - m_cacheBuffer;
621 const qreal bufferTo = to + m_cacheBuffer;
623 bool added = addVisibleItems(from, to,
false);
624 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
625 added |= addVisibleItems(bufferFrom, bufferTo,
true);
627 if (added || removed) {
628 m_contentHeightDirty =
true;
632 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
637 if (m_delegateModel->count() == 0)
645 if (!m_visibleItems.isEmpty()) {
646 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
647 item = m_visibleItems.last();
648 pos = item->y() + item->height() + m_clipItem->y();
650 bool changed =
false;
652 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
654 if (!(item = createItem(modelIndex, asynchronous)))
656 pos += item->height();
663 if (!m_visibleItems.isEmpty()) {
664 modelIndex = m_firstVisibleIndex - 1;
665 item = m_visibleItems.first();
666 pos = item->y() + m_clipItem->y();
668 while (modelIndex >= 0 && pos > fillFrom) {
670 if (!(item = createItem(modelIndex, asynchronous)))
672 pos -= item->height();
680 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
682 QQuickItem *item = listItem->m_item;
683 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
684 if (flags & QQmlDelegateModel::Destroyed) {
685 item->setParentItem(
nullptr);
687 listItem->sectionItem()->deleteLater();
691 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
693 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
694 itemPrivate->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
695 m_itemsToRelease << listItem;
698 void ListViewWithPageHeader::updateWatchedRoles()
700 if (m_delegateModel) {
701 QList<QByteArray> roles;
702 if (!m_sectionProperty.isEmpty())
703 roles << m_sectionProperty.toUtf8();
704 m_delegateModel->setWatchedRoles(roles);
708 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
710 if (!m_sectionDelegate)
713 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
715 if (modelIndex > 0) {
716 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
717 if (section == prevSection)
720 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
722 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
723 if (section == nextSection) {
725 ListItem *nextItem = itemAtIndex(modelIndex);
727 QQuickItem *sectionItem = nextItem->sectionItem();
728 nextItem->setSectionItem(
nullptr);
734 return getSectionItem(section);
737 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText)
739 QQuickItem *sectionItem =
nullptr;
741 QQmlContext *creationContext = m_sectionDelegate->creationContext();
742 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
743 context->setContextProperty(QLatin1String(
"section"), sectionText);
744 context->setContextProperty(QLatin1String(
"delegateIndex"), -1);
745 QObject *nobj = m_sectionDelegate->beginCreate(context);
747 QQml_setParent_noEvent(context, nobj);
748 sectionItem = qobject_cast<QQuickItem *>(nobj);
752 sectionItem->setZ(2);
753 QQml_setParent_noEvent(sectionItem, m_clipItem);
754 sectionItem->setParentItem(m_clipItem);
759 m_sectionDelegate->completeCreate();
766 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
771 if (contentY() < -m_minYExtent) {
773 }
else if (contentY() + height() > contentHeight()) {
776 bool changed =
false;
778 bool foundVisible =
false;
780 int removedItems = 0;
781 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
782 while (i < m_visibleItems.count()) {
783 ListItem *item = m_visibleItems[i];
784 const qreal pos = item->y() + m_clipItem->y();
786 if (pos + item->height() < bufferFrom || pos > bufferTo) {
789 m_visibleItems.removeAt(i);
795 const int itemIndex = m_firstVisibleIndex + removedItems + i;
796 m_firstVisibleIndex = itemIndex;
802 m_firstVisibleIndex = -1;
804 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
811 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
814 if (asynchronous && m_asyncRequestedIndex != -1)
817 m_asyncRequestedIndex = -1;
818 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
819 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
822 m_delegateModel->release(
object);
823 if (!m_delegateValidated) {
824 m_delegateValidated =
true;
825 QObject* delegateObj = delegate();
826 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
829 m_asyncRequestedIndex = modelIndex;
834 ListItem *listItem =
new ListItem;
835 listItem->m_item = item;
836 listItem->setSectionItem(getSectionItem(modelIndex,
false ));
837 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
838 ListItem *prevItem = itemAtIndex(modelIndex - 1);
839 bool lostItem =
false;
843 listItem->setY(prevItem->y() + prevItem->height());
845 ListItem *currItem = itemAtIndex(modelIndex);
848 listItem->setY(currItem->y() - listItem->height());
850 ListItem *nextItem = itemAtIndex(modelIndex + 1);
852 listItem->setY(nextItem->y() - listItem->height());
853 }
else if (modelIndex == 0) {
854 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
855 }
else if (!m_visibleItems.isEmpty()) {
861 listItem->setCulled(
true);
862 releaseItem(listItem);
865 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
866 if (m_visibleItems.isEmpty()) {
867 m_visibleItems << listItem;
869 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
871 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
872 m_firstVisibleIndex = modelIndex;
875 if (listItem->sectionItem()) {
876 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
877 context->setContextProperty(QLatin1String(
"delegateIndex"), modelIndex);
880 m_contentHeightDirty =
true;
886 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
888 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
890 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
897 if (!QQmlEngine::contextForObject(
this)->parentContext())
900 item->setParentItem(m_clipItem);
901 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
902 context->setContextProperty(QLatin1String(
"ListViewWithPageHeader"),
this);
903 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
904 if (modelIndex == m_asyncRequestedIndex) {
905 createItem(modelIndex,
false);
910 void ListViewWithPageHeader::updateClipItem()
912 m_clipItem->setHeight(height() - m_headerItemShownHeight);
913 m_clipItem->setY(contentY() + m_headerItemShownHeight);
914 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
917 void ListViewWithPageHeader::onContentHeightChanged()
922 void ListViewWithPageHeader::onContentWidthChanged()
924 m_clipItem->setWidth(contentItem()->width());
927 void ListViewWithPageHeader::onHeightChanged()
933 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
937 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
939 Q_FOREACH(
const QQmlChangeSet::Remove &
remove, changeSet.removes()) {
941 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
942 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
945 bool growDown =
true;
946 for (
int i = 0; growDown && i <
remove.count; ++i) {
947 const int modelIndex =
remove.index + i;
948 ListItem *item = itemAtIndex(modelIndex);
949 if (item && !item->culled()) {
953 for (
int i =
remove.count - 1; i >= 0; --i) {
954 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
955 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
956 ListItem *item = m_visibleItems[visibleIndex];
958 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
959 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
960 if (!nextItem->sectionItem()) {
961 nextItem->setSectionItem(item->sectionItem());
962 item->setSectionItem(
nullptr);
966 m_visibleItems.removeAt(visibleIndex);
971 }
else if (
remove.index <= m_firstVisibleIndex) {
972 if (!m_visibleItems.isEmpty()) {
975 m_visibleItems.first()->setY(oldFirstValidIndexPos);
977 m_firstVisibleIndex = -1;
980 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
981 m_firstVisibleIndex -=
remove.count;
983 for (
int i =
remove.count - 1; i >= 0; --i) {
984 const int modelIndex =
remove.index + i;
985 if (modelIndex == m_asyncRequestedIndex) {
986 m_asyncRequestedIndex = -1;
987 }
else if (modelIndex < m_asyncRequestedIndex) {
988 m_asyncRequestedIndex--;
993 Q_FOREACH(
const QQmlChangeSet::Insert &insert, changeSet.inserts()) {
995 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
996 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
997 if (insertingInValidIndexes || firstItemWithViewOnTop)
1001 bool growUp =
false;
1002 if (!firstItemWithViewOnTop) {
1003 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1004 if (!m_visibleItems[i]->culled()) {
1005 if (insert.index <= m_firstVisibleIndex + i) {
1013 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1014 for (
int i = insert.count - 1; i >= 0; --i) {
1015 const int modelIndex = insert.index + i;
1016 ListItem *item = createItem(modelIndex,
false);
1018 ListItem *firstItem = m_visibleItems.first();
1019 firstItem->setY(firstItem->y() - item->height());
1023 if (m_sectionDelegate) {
1024 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1025 if (nextItem && !nextItem->sectionItem()) {
1026 nextItem->setSectionItem(getSectionItem(modelIndex + 1,
true ));
1027 if (growUp && nextItem->sectionItem()) {
1028 ListItem *firstItem = m_visibleItems.first();
1029 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1034 if (firstItemWithViewOnTop) {
1035 ListItem *firstItem = m_visibleItems.first();
1036 firstItem->setY(oldFirstValidIndexPos);
1039 }
else if (insert.index <= m_firstVisibleIndex) {
1040 m_firstVisibleIndex += insert.count;
1043 for (
int i = insert.count - 1; i >= 0; --i) {
1044 const int modelIndex = insert.index + i;
1045 if (modelIndex <= m_asyncRequestedIndex) {
1046 m_asyncRequestedIndex++;
1051 Q_FOREACH(
const QQmlChangeSet::Change &change, changeSet.changes()) {
1053 for (
int i = change.index; i < change.count; ++i) {
1054 ListItem *item = itemAtIndex(i);
1055 if (item && item->sectionItem()) {
1056 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1057 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);
1058 context->setContextProperty(QLatin1String(
"section"), sectionText);
1063 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1067 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1068 ListItem *item = m_visibleItems[i];
1069 if (item->sectionItem()) {
1070 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1071 context->setContextProperty(QLatin1String(
"delegateIndex"), m_firstVisibleIndex + i);
1077 m_contentHeightDirty =
true;
1080 void ListViewWithPageHeader::contentYAnimationRunningChanged(
bool running)
1082 setInteractive(!running);
1084 m_contentHeightDirty =
true;
1089 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * ,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1091 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1092 if (heightDiff != 0) {
1093 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1094 ListItem *firstItem = m_visibleItems.first();
1095 firstItem->setY(firstItem->y() - heightDiff);
1102 m_contentHeightDirty =
true;
1106 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1108 if (item == m_headerItem) {
1109 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1112 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1115 m_contentHeightDirty =
true;
1120 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1122 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1123 if (m_headerItemShownHeight > 0) {
1126 m_headerItemShownHeight += heightDiff;
1127 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1130 Q_EMIT headerItemShownHeightChanged();
1132 if (oldHeaderY + oldHeaderHeight > contentY()) {
1135 ListItem *firstItem = m_visibleItems.first();
1136 firstItem->setY(firstItem->y() + heightDiff);
1147 void ListViewWithPageHeader::adjustMinYExtent()
1149 if (m_visibleItems.isEmpty()) {
1152 qreal nonCreatedHeight = 0;
1153 if (m_firstVisibleIndex != 0) {
1155 const int visibleItems = m_visibleItems.count();
1156 qreal visibleItemsHeight = 0;
1157 Q_FOREACH(ListItem *item, m_visibleItems) {
1158 visibleItemsHeight += item->height();
1160 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1163 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1164 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1165 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1167 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1172 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const
1174 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1175 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1176 return m_visibleItems[visibleIndexedModelIndex];
1181 void ListViewWithPageHeader::layout()
1187 if (!m_visibleItems.isEmpty()) {
1188 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1189 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1191 qreal pos = m_visibleItems.first()->y();
1194 int firstReallyVisibleItem = -1;
1195 int modelIndex = m_firstVisibleIndex;
1196 Q_FOREACH(ListItem *item, m_visibleItems) {
1197 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1198 item->setCulled(cull);
1200 if (!cull && firstReallyVisibleItem == -1) {
1201 firstReallyVisibleItem = modelIndex;
1202 if (m_topSectionItem) {
1208 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1209 bool showStickySectionItem;
1214 if (topSectionStickPos > pos) {
1215 showStickySectionItem =
true;
1216 }
else if (topSectionStickPos == pos) {
1217 showStickySectionItem = !item->sectionItem();
1219 showStickySectionItem =
false;
1221 if (!showStickySectionItem) {
1222 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1223 if (item->sectionItem()) {
1228 QQuickItemPrivate::get(item->sectionItem())->setCulled(
false);
1232 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1233 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1234 context->setContextProperty(QLatin1String(
"section"), section);
1236 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1237 m_topSectionItem->setY(topSectionStickPos);
1238 int delegateIndex = modelIndex;
1240 while (delegateIndex > 0) {
1241 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1242 if (prevSection != section)
1246 context->setContextProperty(QLatin1String(
"delegateIndex"), delegateIndex);
1247 if (item->sectionItem()) {
1248 QQuickItemPrivate::get(item->sectionItem())->setCulled(
true);
1253 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1254 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1255 if (!cull && pos < clipFrom) {
1256 context->setContextProperty(QLatin1String(
"heightToClip"), clipFrom - pos);
1258 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
1261 pos += item->height();
1267 if (m_topSectionItem) {
1268 if (firstReallyVisibleItem >= 0) {
1269 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1270 ListItem *item = m_visibleItems[i];
1271 if (item->sectionItem()) {
1272 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1273 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1284 void ListViewWithPageHeader::updatePolish()
1289 if (!QQmlEngine::contextForObject(
this)->parentContext())
1292 Q_FOREACH(ListItem *item, m_itemsToRelease)
1293 reallyReleaseItem(item);
1294 m_itemsToRelease.clear();
1303 if (m_contentHeightDirty) {
1304 qreal contentHeight;
1305 if (m_visibleItems.isEmpty()) {
1306 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1308 const int modelCount = model()->rowCount();
1309 const int visibleItems = m_visibleItems.count();
1310 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1311 qreal nonCreatedHeight = 0;
1312 if (lastValidIndex != modelCount - 1) {
1313 const int visibleItems = m_visibleItems.count();
1314 qreal visibleItemsHeight = 0;
1315 Q_FOREACH(ListItem *item, m_visibleItems) {
1316 visibleItemsHeight += item->height();
1318 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1319 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1321 ListItem *item = m_visibleItems.last();
1322 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1323 if (m_firstVisibleIndex != 0) {
1325 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1329 m_contentHeightDirty =
false;
1331 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1332 setContentHeight(contentHeight);
1333 m_inContentHeightKeepHeaderShown =
false;
1337 #include "moc_listviewwithpageheader.cpp"