92 #include "listviewwithpageheader.h"
94 #include <QCoreApplication>
97 #include <qqmlengine.h>
98 #pragma GCC diagnostic push
99 #pragma GCC diagnostic ignored "-pedantic"
100 #include <private/qqmldelegatemodel_p.h>
101 #include <private/qqmlglobal_p.h>
102 #include <private/qquickitem_p.h>
103 #include <private/qquickanimation_p.h>
104 #pragma GCC diagnostic pop
107 static const qreal bufferRatio = 0.5;
109 qreal ListViewWithPageHeader::ListItem::height()
const
111 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
114 qreal ListViewWithPageHeader::ListItem::y()
const
116 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
119 void ListViewWithPageHeader::ListItem::setY(qreal newY)
122 m_sectionItem->setY(newY);
123 m_item->setY(newY + m_sectionItem->height());
129 bool ListViewWithPageHeader::ListItem::culled()
const
131 return QQuickItemPrivate::get(m_item)->culled;
134 void ListViewWithPageHeader::ListItem::setCulled(
bool culled)
136 QQuickItemPrivate::get(m_item)->setCulled(culled);
138 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
141 ListViewWithPageHeader::ListViewWithPageHeader()
142 : m_delegateModel(nullptr)
143 , m_asyncRequestedIndex(-1)
144 , m_delegateValidated(false)
145 , m_firstVisibleIndex(-1)
147 , m_contentHeightDirty(false)
148 , m_headerItem(nullptr)
149 , m_previousContentY(0)
150 , m_headerItemShownHeight(0)
151 , m_sectionDelegate(nullptr)
152 , m_topSectionItem(nullptr)
153 , m_forceNoClip(false)
155 , m_inContentHeightKeepHeaderShown(false)
157 m_clipItem =
new QQuickItem(contentItem());
161 m_contentYAnimation =
new QQuickNumberAnimation(
this);
162 m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
163 m_contentYAnimation->setProperty(
"contentY");
164 m_contentYAnimation->setDuration(200);
165 m_contentYAnimation->setTargetObject(
this);
167 connect(
this, SIGNAL(contentWidthChanged()),
this, SLOT(onContentWidthChanged()));
168 connect(
this, SIGNAL(contentHeightChanged()),
this, SLOT(onContentHeightChanged()));
169 connect(
this, SIGNAL(heightChanged()),
this, SLOT(onHeightChanged()));
170 connect(m_contentYAnimation, SIGNAL(stopped()),
this, SLOT(onShowHeaderAnimationFinished()));
172 setFlickableDirection(VerticalFlick);
175 ListViewWithPageHeader::~ListViewWithPageHeader()
179 QAbstractItemModel *ListViewWithPageHeader::model()
const
181 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() :
nullptr;
184 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
186 if (model != this->model()) {
187 if (!m_delegateModel) {
188 createDelegateModel();
190 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
192 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
193 connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,
bool)),
this, SLOT(onModelUpdated(QQmlChangeSet,
bool)));
194 Q_EMIT modelChanged();
202 QQmlComponent *ListViewWithPageHeader::delegate()
const
204 return m_delegateModel ? m_delegateModel->delegate() :
nullptr;
207 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
209 if (delegate != this->delegate()) {
210 if (!m_delegateModel) {
211 createDelegateModel();
215 Q_FOREACH(ListItem *item, m_visibleItems)
217 m_visibleItems.clear();
218 m_firstVisibleIndex = -1;
222 if (m_topSectionItem) {
223 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
226 m_delegateModel->setDelegate(delegate);
228 Q_EMIT delegateChanged();
229 m_delegateValidated =
false;
230 m_contentHeightDirty =
true;
235 QQuickItem *ListViewWithPageHeader::header()
const
240 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
242 if (m_headerItem != headerItem) {
243 qreal oldHeaderHeight = 0;
244 qreal oldHeaderY = 0;
246 oldHeaderHeight = m_headerItem->height();
247 oldHeaderY = m_headerItem->y();
248 m_headerItem->setParentItem(
nullptr);
250 m_headerItem = headerItem;
252 m_headerItem->setParentItem(contentItem());
253 m_headerItem->setZ(1);
255 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
256 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
257 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
259 m_contentHeightDirty =
true;
261 Q_EMIT headerChanged();
265 QQmlComponent *ListViewWithPageHeader::sectionDelegate()
const
267 return m_sectionDelegate;
270 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
272 if (delegate != m_sectionDelegate) {
275 m_sectionDelegate = delegate;
277 m_topSectionItem = getSectionItem(QString());
278 m_topSectionItem->setZ(3);
279 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
280 connect(m_topSectionItem, SIGNAL(heightChanged()), SIGNAL(stickyHeaderHeightChanged()));
284 Q_EMIT sectionDelegateChanged();
285 Q_EMIT stickyHeaderHeightChanged();
289 QString ListViewWithPageHeader::sectionProperty()
const
291 return m_sectionProperty;
294 void ListViewWithPageHeader::setSectionProperty(
const QString &property)
296 if (property != m_sectionProperty) {
297 m_sectionProperty = property;
299 updateWatchedRoles();
303 Q_EMIT sectionPropertyChanged();
307 bool ListViewWithPageHeader::forceNoClip()
const
309 return m_forceNoClip;
312 void ListViewWithPageHeader::setForceNoClip(
bool noClip)
314 if (noClip != m_forceNoClip) {
315 m_forceNoClip = noClip;
317 Q_EMIT forceNoClipChanged();
321 int ListViewWithPageHeader::stickyHeaderHeight()
const
323 return m_topSectionItem ? m_topSectionItem->height() : 0;
326 void ListViewWithPageHeader::positionAtBeginning()
328 if (m_delegateModel->count() <= 0)
331 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
332 if (m_firstVisibleIndex != 0) {
336 Q_FOREACH(ListItem *item, m_visibleItems)
338 m_visibleItems.clear();
339 m_firstVisibleIndex = -1;
343 ListItem *item = createItem(0, false);
346 qreal pos = item->y() + item->height();
347 const qreal buffer = height() * bufferRatio;
348 const qreal bufferTo = height() + buffer;
349 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
350 if (!(item = createItem(modelIndex,
false)))
352 pos += item->height();
356 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
358 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
364 m_headerItem->setY(-m_minYExtent);
368 static inline bool uFuzzyCompare(qreal r1, qreal r2)
370 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
373 void ListViewWithPageHeader::showHeader()
378 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
379 if (!uFuzzyCompare(to, contentY())) {
380 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
381 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
385 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
386 if (!m_visibleItems.isEmpty()) {
388 ListItem *firstItem = m_visibleItems.first();
389 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
393 m_contentYAnimation->setTo(to);
394 contentYAnimationType = ContentYAnimationShowHeader;
395 m_contentYAnimation->start();
399 QQuickItem *ListViewWithPageHeader::item(
int modelIndex)
const
401 ListItem *item = itemAtIndex(modelIndex);
408 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex)
410 ListItem *listItem = itemAtIndex(modelIndex);
412 return maximizeVisibleArea(listItem, listItem->height());
418 bool ListViewWithPageHeader::maximizeVisibleArea(
int modelIndex,
int itemHeight)
423 ListItem *listItem = itemAtIndex(modelIndex);
425 return maximizeVisibleArea(listItem, itemHeight + (listItem->m_sectionItem ? listItem->m_sectionItem->height() : 0));
431 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem,
int listItemHeight)
435 const auto listItemY = m_clipItem->y() + listItem->y();
436 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
438 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
439 m_contentYAnimation->setTo(to);
440 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
441 m_contentYAnimation->start();
442 }
else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
443 (m_topSectionItem && !listItem->m_sectionItem && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
446 auto realVisibleListItemY = listItemY;
447 if (m_topSectionItem) {
451 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
452 if (topSectionShown && !listItem->m_sectionItem) {
453 realVisibleListItemY -= m_topSectionItem->height();
456 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
457 m_contentYAnimation->setTo(to);
458 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
459 m_contentYAnimation->start();
466 qreal ListViewWithPageHeader::minYExtent()
const
472 void ListViewWithPageHeader::componentComplete()
475 m_delegateModel->componentComplete();
477 QQuickFlickable::componentComplete();
482 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
487 if (!QQmlEngine::contextForObject(
this)->parentContext())
490 QQuickFlickable::viewportMoved(orient);
492 qreal diff = m_previousContentY - contentY();
493 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
495 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
496 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
497 m_headerItem->setHeight(m_headerItem->implicitHeight());
501 const bool scrolledUp = m_previousContentY > contentY();
502 const bool notRebounding = contentY() + height() < contentHeight();
503 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
504 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
506 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
507 m_headerItemShownHeight = 0;
508 m_headerItem->setY(-m_minYExtent);
509 }
else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
510 if (maximizeVisibleAreaRunning && diff > 0) {
512 m_headerItemShownHeight -= diff;
514 m_headerItemShownHeight += diff;
516 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
517 m_headerItemShownHeight = 0;
519 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
521 if (m_headerItemShownHeight > 0) {
522 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
523 m_headerItem->setY(contentY());
524 m_headerItemShownHeight = m_headerItem->height();
526 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
529 m_headerItem->setY(-m_minYExtent);
534 m_headerItem->setY(contentY());
535 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
540 if (!showHeaderAnimationRunning) {
541 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
546 if (!m_visibleItems.isEmpty()) {
548 ListItem *firstItem = m_visibleItems.first();
549 firstItem->setY(firstItem->y() + diff);
550 if (showHeaderAnimationRunning) {
555 m_previousContentY = contentY();
560 void ListViewWithPageHeader::createDelegateModel()
562 m_delegateModel =
new QQmlDelegateModel(qmlContext(
this),
this);
563 connect(m_delegateModel, SIGNAL(createdItem(
int,QObject*)),
this, SLOT(itemCreated(
int,QObject*)));
564 if (isComponentComplete())
565 m_delegateModel->componentComplete();
566 updateWatchedRoles();
569 void ListViewWithPageHeader::refill()
574 if (!isComponentComplete()) {
578 const qreal buffer = height() * bufferRatio;
579 const qreal from = contentY();
580 const qreal to = from + height();
581 const qreal bufferFrom = from - buffer;
582 const qreal bufferTo = to + buffer;
584 bool added = addVisibleItems(from, to,
false);
585 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
586 added |= addVisibleItems(bufferFrom, bufferTo,
true);
588 if (added || removed) {
589 m_contentHeightDirty =
true;
593 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo,
bool asynchronous)
598 if (m_delegateModel->count() == 0)
606 if (!m_visibleItems.isEmpty()) {
607 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
608 item = m_visibleItems.last();
609 pos = item->y() + item->height() + m_clipItem->y();
611 bool changed =
false;
613 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
615 if (!(item = createItem(modelIndex, asynchronous)))
617 pos += item->height();
624 if (!m_visibleItems.isEmpty()) {
625 modelIndex = m_firstVisibleIndex - 1;
626 item = m_visibleItems.first();
627 pos = item->y() + m_clipItem->y();
629 while (modelIndex >= 0 && pos > fillFrom) {
631 if (!(item = createItem(modelIndex, asynchronous)))
633 pos -= item->height();
641 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
643 QQuickItem *item = listItem->m_item;
644 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
645 if (flags & QQmlDelegateModel::Destroyed) {
646 item->setParentItem(
nullptr);
648 delete listItem->m_sectionItem;
652 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
654 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
655 itemPrivate->removeItemChangeListener(
this, QQuickItemPrivate::Geometry);
656 m_itemsToRelease << listItem;
659 void ListViewWithPageHeader::updateWatchedRoles()
661 if (m_delegateModel) {
662 QList<QByteArray> roles;
663 if (!m_sectionProperty.isEmpty())
664 roles << m_sectionProperty.toUtf8();
665 m_delegateModel->setWatchedRoles(roles);
669 QQuickItem *ListViewWithPageHeader::getSectionItem(
int modelIndex,
bool alreadyInserted)
671 if (!m_sectionDelegate)
674 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
675 if (modelIndex > 0) {
676 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
677 if (section == prevSection)
680 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
682 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
683 if (section == nextSection) {
685 ListItem *nextItem = itemAtIndex(modelIndex);
687 QQuickItem *sectionItem = nextItem->m_sectionItem;
688 nextItem->m_sectionItem =
nullptr;
694 return getSectionItem(section);
697 QQuickItem *ListViewWithPageHeader::getSectionItem(
const QString §ionText)
699 QQuickItem *sectionItem =
nullptr;
701 QQmlContext *creationContext = m_sectionDelegate->creationContext();
702 QQmlContext *context =
new QQmlContext(creationContext ? creationContext : qmlContext(
this));
703 context->setContextProperty(QLatin1String(
"section"), sectionText);
704 context->setContextProperty(QLatin1String(
"delegateIndex"), -1);
705 QObject *nobj = m_sectionDelegate->beginCreate(context);
707 QQml_setParent_noEvent(context, nobj);
708 sectionItem = qobject_cast<QQuickItem *>(nobj);
712 sectionItem->setZ(2);
713 QQml_setParent_noEvent(sectionItem, m_clipItem);
714 sectionItem->setParentItem(m_clipItem);
719 m_sectionDelegate->completeCreate();
726 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
731 if (contentY() < -m_minYExtent) {
733 }
else if (contentY() + height() > contentHeight()) {
736 bool changed =
false;
738 bool foundVisible =
false;
740 int removedItems = 0;
741 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
742 while (i < m_visibleItems.count()) {
743 ListItem *item = m_visibleItems[i];
744 const qreal pos = item->y() + m_clipItem->y();
746 if (pos + item->height() < bufferFrom || pos > bufferTo) {
749 m_visibleItems.removeAt(i);
755 const int itemIndex = m_firstVisibleIndex + removedItems + i;
756 m_firstVisibleIndex = itemIndex;
762 m_firstVisibleIndex = -1;
764 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
771 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(
int modelIndex,
bool asynchronous)
774 if (asynchronous && m_asyncRequestedIndex != -1)
777 m_asyncRequestedIndex = -1;
778 QObject*
object = m_delegateModel->object(modelIndex, asynchronous);
779 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
782 m_delegateModel->release(
object);
783 if (!m_delegateValidated) {
784 m_delegateValidated =
true;
785 QObject* delegateObj = delegate();
786 qmlInfo(delegateObj ? delegateObj :
this) <<
"Delegate must be of Item type";
789 m_asyncRequestedIndex = modelIndex;
794 ListItem *listItem =
new ListItem;
795 listItem->m_item = item;
796 listItem->m_sectionItem = getSectionItem(modelIndex,
false );
797 QQuickItemPrivate::get(item)->addItemChangeListener(
this, QQuickItemPrivate::Geometry);
798 ListItem *prevItem = itemAtIndex(modelIndex - 1);
799 bool lostItem =
false;
803 listItem->setY(prevItem->y() + prevItem->height());
805 ListItem *currItem = itemAtIndex(modelIndex);
808 listItem->setY(currItem->y() - listItem->height());
810 ListItem *nextItem = itemAtIndex(modelIndex + 1);
812 listItem->setY(nextItem->y() - listItem->height());
813 }
else if (modelIndex == 0 && m_headerItem) {
814 listItem->setY(m_headerItem->height());
815 }
else if (!m_visibleItems.isEmpty()) {
821 listItem->setCulled(
true);
822 releaseItem(listItem);
825 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
826 if (m_visibleItems.isEmpty()) {
827 m_visibleItems << listItem;
829 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
831 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
832 m_firstVisibleIndex = modelIndex;
835 if (listItem->m_sectionItem) {
836 QQmlContext *context = QQmlEngine::contextForObject(listItem->m_sectionItem)->parentContext();
837 context->setContextProperty(QLatin1String(
"delegateIndex"), modelIndex);
840 m_contentHeightDirty =
true;
846 void ListViewWithPageHeader::itemCreated(
int modelIndex, QObject *
object)
848 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
850 qWarning() <<
"ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
857 if (!QQmlEngine::contextForObject(
this)->parentContext())
860 item->setParentItem(m_clipItem);
861 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
862 context->setContextProperty(QLatin1String(
"ListViewWithPageHeader"),
this);
863 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
864 if (modelIndex == m_asyncRequestedIndex) {
865 createItem(modelIndex,
false);
870 void ListViewWithPageHeader::updateClipItem()
872 m_clipItem->setHeight(height() - m_headerItemShownHeight);
873 m_clipItem->setY(contentY() + m_headerItemShownHeight);
874 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
877 void ListViewWithPageHeader::onContentHeightChanged()
882 void ListViewWithPageHeader::onContentWidthChanged()
884 m_clipItem->setWidth(contentItem()->width());
887 void ListViewWithPageHeader::onHeightChanged()
893 void ListViewWithPageHeader::onModelUpdated(
const QQmlChangeSet &changeSet,
bool )
897 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
899 Q_FOREACH(
const QQmlChangeSet::Remove &
remove, changeSet.removes()) {
901 if (
remove.index +
remove.count > m_firstVisibleIndex &&
remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
902 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
905 bool growDown =
true;
906 for (
int i = 0; growDown && i <
remove.count; ++i) {
907 const int modelIndex =
remove.index + i;
908 ListItem *item = itemAtIndex(modelIndex);
909 if (item && !item->culled()) {
913 for (
int i =
remove.count - 1; i >= 0; --i) {
914 const int visibleIndex =
remove.index + i - m_firstVisibleIndex;
915 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
916 ListItem *item = m_visibleItems[visibleIndex];
918 if (item->m_sectionItem && visibleIndex + 1 < m_visibleItems.count()) {
919 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
920 if (!nextItem->m_sectionItem) {
921 nextItem->m_sectionItem = item->m_sectionItem;
922 item->m_sectionItem =
nullptr;
926 m_visibleItems.removeAt(visibleIndex);
931 }
else if (
remove.index <= m_firstVisibleIndex) {
932 if (!m_visibleItems.isEmpty()) {
935 m_visibleItems.first()->setY(oldFirstValidIndexPos);
937 m_firstVisibleIndex = -1;
940 }
else if (
remove.index +
remove.count <= m_firstVisibleIndex) {
941 m_firstVisibleIndex -=
remove.count;
943 for (
int i =
remove.count - 1; i >= 0; --i) {
944 const int modelIndex =
remove.index + i;
945 if (modelIndex == m_asyncRequestedIndex) {
946 m_asyncRequestedIndex = -1;
947 }
else if (modelIndex < m_asyncRequestedIndex) {
948 m_asyncRequestedIndex--;
953 Q_FOREACH(
const QQmlChangeSet::Insert &insert, changeSet.inserts()) {
955 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
956 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
957 if (insertingInValidIndexes || firstItemWithViewOnTop)
962 if (!firstItemWithViewOnTop) {
963 for (
int i = 0; i < m_visibleItems.count(); ++i) {
964 if (!m_visibleItems[i]->culled()) {
965 if (insert.index <= m_firstVisibleIndex + i) {
973 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
974 for (
int i = insert.count - 1; i >= 0; --i) {
975 const int modelIndex = insert.index + i;
976 ListItem *item = createItem(modelIndex,
false);
978 ListItem *firstItem = m_visibleItems.first();
979 firstItem->setY(firstItem->y() - item->height());
983 if (m_sectionDelegate) {
984 ListItem *nextItem = itemAtIndex(modelIndex + 1);
985 if (nextItem && !nextItem->m_sectionItem) {
986 nextItem->m_sectionItem = getSectionItem(modelIndex + 1,
true );
987 if (growUp && nextItem->m_sectionItem) {
988 ListItem *firstItem = m_visibleItems.first();
989 firstItem->setY(firstItem->y() - nextItem->m_sectionItem->height());
994 if (firstItemWithViewOnTop) {
995 ListItem *firstItem = m_visibleItems.first();
996 firstItem->setY(oldFirstValidIndexPos);
999 }
else if (insert.index <= m_firstVisibleIndex) {
1000 m_firstVisibleIndex += insert.count;
1003 for (
int i = insert.count - 1; i >= 0; --i) {
1004 const int modelIndex = insert.index + i;
1005 if (modelIndex <= m_asyncRequestedIndex) {
1006 m_asyncRequestedIndex++;
1011 Q_FOREACH(
const QQmlChangeSet::Change &change, changeSet.changes()) {
1013 for (
int i = change.index; i < change.count; ++i) {
1014 ListItem *item = itemAtIndex(i);
1015 if (item && item->m_sectionItem) {
1016 QQmlContext *context = QQmlEngine::contextForObject(item->m_sectionItem)->parentContext();
1017 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);
1018 context->setContextProperty(QLatin1String(
"section"), sectionText);
1023 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1027 for (
int i = 0; i < m_visibleItems.count(); ++i) {
1028 ListItem *item = m_visibleItems[i];
1029 if (item->m_sectionItem) {
1030 QQmlContext *context = QQmlEngine::contextForObject(item->m_sectionItem)->parentContext();
1031 context->setContextProperty(QLatin1String(
"delegateIndex"), m_firstVisibleIndex + i);
1037 m_contentHeightDirty =
true;
1040 void ListViewWithPageHeader::onShowHeaderAnimationFinished()
1042 m_contentHeightDirty =
true;
1046 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * ,
const QRectF &newGeometry,
const QRectF &oldGeometry)
1048 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1049 if (heightDiff != 0) {
1050 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1051 ListItem *firstItem = m_visibleItems.first();
1052 firstItem->setY(firstItem->y() - heightDiff);
1059 m_contentHeightDirty =
true;
1063 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1065 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1066 if (m_headerItemShownHeight > 0) {
1069 m_headerItemShownHeight += heightDiff;
1070 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1074 if (oldHeaderY + oldHeaderHeight > contentY()) {
1077 ListItem *firstItem = m_visibleItems.first();
1078 firstItem->setY(firstItem->y() + heightDiff);
1089 void ListViewWithPageHeader::adjustMinYExtent()
1091 if (m_visibleItems.isEmpty()) {
1094 qreal nonCreatedHeight = 0;
1095 if (m_firstVisibleIndex != 0) {
1097 const int visibleItems = m_visibleItems.count();
1098 qreal visibleItemsHeight = 0;
1099 Q_FOREACH(ListItem *item, m_visibleItems) {
1100 visibleItemsHeight += item->height();
1102 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1105 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1106 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1107 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1109 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1114 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(
int modelIndex)
const
1116 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1117 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1118 return m_visibleItems[visibleIndexedModelIndex];
1123 void ListViewWithPageHeader::layout()
1129 if (!m_visibleItems.isEmpty()) {
1130 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1131 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1133 qreal pos = m_visibleItems.first()->y();
1136 int firstReallyVisibleItem = -1;
1137 int modelIndex = m_firstVisibleIndex;
1138 Q_FOREACH(ListItem *item, m_visibleItems) {
1139 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1140 item->setCulled(cull);
1142 if (!cull && firstReallyVisibleItem == -1) {
1143 firstReallyVisibleItem = modelIndex;
1144 if (m_topSectionItem) {
1150 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1151 bool showStickySectionItem;
1156 if (topSectionStickPos > pos) {
1157 showStickySectionItem =
true;
1158 }
else if (topSectionStickPos == pos) {
1159 showStickySectionItem = !item->m_sectionItem;
1161 showStickySectionItem =
false;
1163 if (!showStickySectionItem) {
1164 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
true);
1165 if (item->m_sectionItem) {
1170 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(
false);
1174 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1175 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1176 context->setContextProperty(QLatin1String(
"section"), section);
1178 QQuickItemPrivate::get(m_topSectionItem)->setCulled(
false);
1179 m_topSectionItem->setY(topSectionStickPos);
1180 int delegateIndex = modelIndex;
1182 while (delegateIndex > 0) {
1183 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1184 if (prevSection != section)
1188 context->setContextProperty(QLatin1String(
"delegateIndex"), delegateIndex);
1189 if (item->m_sectionItem) {
1190 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(
true);
1195 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1196 const qreal clipFrom = visibleFrom + (!item->m_sectionItem && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1197 if (!cull && pos < clipFrom) {
1198 context->setContextProperty(QLatin1String(
"heightToClip"), clipFrom - pos);
1200 context->setContextProperty(QLatin1String(
"heightToClip"), QVariant::fromValue<int>(0));
1203 pos += item->height();
1209 if (m_topSectionItem) {
1210 if (firstReallyVisibleItem >= 0) {
1211 for (
int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1212 ListItem *item = m_visibleItems[i];
1213 if (item->m_sectionItem) {
1214 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1215 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1226 void ListViewWithPageHeader::updatePolish()
1231 if (!QQmlEngine::contextForObject(
this)->parentContext())
1234 Q_FOREACH(ListItem *item, m_itemsToRelease)
1235 reallyReleaseItem(item);
1236 m_itemsToRelease.clear();
1245 if (m_contentHeightDirty) {
1246 qreal contentHeight;
1247 if (m_visibleItems.isEmpty()) {
1248 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1250 const int modelCount = model()->rowCount();
1251 const int visibleItems = m_visibleItems.count();
1252 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1253 qreal nonCreatedHeight = 0;
1254 if (lastValidIndex != modelCount - 1) {
1255 const int visibleItems = m_visibleItems.count();
1256 qreal visibleItemsHeight = 0;
1257 Q_FOREACH(ListItem *item, m_visibleItems) {
1258 visibleItemsHeight += item->height();
1260 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1261 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1263 ListItem *item = m_visibleItems.last();
1264 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1265 if (m_firstVisibleIndex != 0) {
1267 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1271 m_contentHeightDirty =
false;
1273 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1274 setContentHeight(contentHeight);
1275 m_inContentHeightKeepHeaderShown =
false;
1279 #include "moc_listviewwithpageheader.cpp"