git.iko.soy/unity8
on aa42683 help sign in
unity8/plugins/Dash/listviewwithpageheader.cpp
1341 lines 53 kB history raw
1/*
2 * Copyright (C) 2013 Canonical, Ltd.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 3.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
17/*
18 * Some documentation on how this thing works:
19 *
20 * A flickable has two very important concepts that define the top and
21 * height of the flickable area.
22 * The top is returned in minYExtent()
23 * The height is set using setContentHeight()
24 * By changing those two values we can make the list grow up or down
25 * as needed. e.g. if we are in the middle of the list
26 * and something that is above the viewport grows, since we do not
27 * want to change the viewport because of that we just adjust the
28 * minYExtent so that the list grows up.
29 *
30 * The implementation on the list relies on the delegateModel doing
31 * most of the instantiation work. You call createItem() when you
32 * need to create an item asking for it async or not. If returns null
33 * it means the item will be created async and the model will call the
34 * itemCreated slot with the item.
35 *
36 * updatePolish is the central point of dispatch for the work of the
37 * class. It is called by the scene graph just before drawing the class.
38 * In it we:
39 * * Make sure all items are positioned correctly
40 * * Add/Remove items if needed
41 * * Update the content height if it was dirty
42 *
43 * m_visibleItems contains all the items we have created at the moment.
44 * Actually not all of them are visible since it includes the ones
45 * in the cache area we create asynchronously to help performance.
46 * The first item in m_visibleItems has the m_firstVisibleIndex in
47 * the model. If you actually want to know what is the first
48 * item in the viewport you have to find the first non culled element
49 * in m_visibleItems
50 *
51 * All the items (except the header) are childs of m_clipItem which
52 * is a child of the contentItem() of the flickable (The contentItem()
53 * is what actually 'moves' in a a flickable). This way
54 * we can implement the clipping needed so we can have the header
55 * shown in the middle of the list over the items without the items
56 * leaking under the header in case it is transparent.
57 *
58 * The first item of m_visibleItems is the one that defines the
59 * positions of all the rest of items (see updatePolish()) and
60 * this is why sometimes we move it even if it's not the item
61 * that has triggered the function (i.e. in itemGeometryChanged())
62 *
63 * m_visibleItems is a list of ListItem. Each ListItem
64 * will contain a item and potentially a sectionItem. The sectionItem
65 * is only there when the list is using sectionDelegate+sectionProperty
66 * and this is the first item of the section. Each ListItem is vertically
67 * layouted with the sectionItem first and then the item.
68 *
69 * For sectioning we also have a section item alone (m_topSectionItem)
70 * that is used for the cases we need to show the sticky section item at
71 * the top of the view.
72 *
73 * Each delegate item has a context property called heightToClip that is
74 * used to communicate to the delegate implementation in case it has to
75 * clip itself because of overlapping with the top sticky section item.
76 * This is an implementation decision since it has been agreed it
77 * is easier to implement the clipping in QML with this info than to
78 * do it at the C++ level.
79 *
80 * Note that minYExtent and height are not always totally accurate, since
81 * we don't have the items created we can't guess their heights
82 * so we can only guarantee the values are correct when the first/last
83 * items of the list are visible, otherwise we just live with good enough
84 * values that make the list scrollable
85 *
86 * There are a few things that are not really implemented or tested properly
87 * which we don't use at the moment like changing the model, changing
88 * the section delegate, having a section delegate that changes its size, etc.
89 * The known missing features are marked with TODOs along the code.
90 */
92#include "listviewwithpageheader.h"
94#include <QCoreApplication>
95#include <QDebug>
96#include <qqmlinfo.h>
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
105// #include <private/qquickrectangle_p.h>
107qreal ListViewWithPageHeader::ListItem::height() const
109 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
112qreal ListViewWithPageHeader::ListItem::y() const
114 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
117void ListViewWithPageHeader::ListItem::setY(qreal newY)
119 if (m_sectionItem) {
120 m_sectionItem->setY(newY);
121 m_item->setY(newY + m_sectionItem->height());
122 } else {
123 m_item->setY(newY);
124 }
127bool ListViewWithPageHeader::ListItem::culled() const
129 return QQuickItemPrivate::get(m_item)->culled;
132void ListViewWithPageHeader::ListItem::setCulled(bool culled)
134 QQuickItemPrivate::get(m_item)->setCulled(culled);
135 if (m_sectionItem)
136 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
139void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
141 m_sectionItem = sectionItem;
144ListViewWithPageHeader::ListViewWithPageHeader()
145 : m_delegateModel(nullptr)
146 , m_asyncRequestedIndex(-1)
147 , m_delegateValidated(false)
148 , m_firstVisibleIndex(-1)
149 , m_minYExtent(0)
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)
157 , m_inLayout(false)
158 , m_inContentHeightKeepHeaderShown(false)
159 , m_cacheBuffer(0)
161 m_clipItem = new QQuickItem(contentItem());
162// m_clipItem = new QQuickRectangle(contentItem());
163// ((QQuickRectangle*)m_clipItem)->setColor(Qt::gray);
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, &ListViewWithPageHeader::contentWidthChanged, this, &ListViewWithPageHeader::onContentWidthChanged);
172 connect(this, &ListViewWithPageHeader::contentHeightChanged, this, &ListViewWithPageHeader::onContentHeightChanged);
173 connect(this, &ListViewWithPageHeader::heightChanged, this, &ListViewWithPageHeader::onHeightChanged);
174 connect(m_contentYAnimation, &QQuickNumberAnimation::runningChanged, this, &ListViewWithPageHeader::contentYAnimationRunningChanged);
176 setFlickableDirection(VerticalFlick);
179ListViewWithPageHeader::~ListViewWithPageHeader()
183QAbstractItemModel *ListViewWithPageHeader::model() const
185 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;
188void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
190 if (model != this->model()) {
191 if (!m_delegateModel) {
192 createDelegateModel();
193 } else {
194 disconnect(m_delegateModel, &QQmlDelegateModel::modelUpdated, this, &ListViewWithPageHeader::onModelUpdated);
195 }
196 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
197 connect(m_delegateModel, &QQmlDelegateModel::modelUpdated, this, &ListViewWithPageHeader::onModelUpdated);
198 Q_EMIT modelChanged();
199 polish();
200 // TODO?
201// Q_EMIT contentHeightChanged();
202// Q_EMIT contentYChanged();
203 }
206QQmlComponent *ListViewWithPageHeader::delegate() const
208 return m_delegateModel ? m_delegateModel->delegate() : nullptr;
211void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
213 if (delegate != this->delegate()) {
214 if (!m_delegateModel) {
215 createDelegateModel();
216 }
218 // Cleanup the existing items
219 Q_FOREACH(ListItem *item, m_visibleItems)
220 releaseItem(item);
221 m_visibleItems.clear();
222 m_firstVisibleIndex = -1;
223 adjustMinYExtent();
224 setContentY(0);
225 m_clipItem->setY(0);
226 if (m_topSectionItem) {
227 QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
228 }
230 m_delegateModel->setDelegate(delegate);
232 Q_EMIT delegateChanged();
233 m_delegateValidated = false;
234 m_contentHeightDirty = true;
235 polish();
236 }
239QQuickItem *ListViewWithPageHeader::header() const
241 return m_headerItem;
244void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
246 if (m_headerItem != headerItem) {
247 qreal oldHeaderHeight = 0;
248 qreal oldHeaderY = 0;
249 if (m_headerItem) {
250 oldHeaderHeight = m_headerItem->height();
251 oldHeaderY = m_headerItem->y();
252 m_headerItem->setParentItem(nullptr);
253 }
254 m_headerItem = headerItem;
255 if (m_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);
260 }
261 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
262 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
263 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
264 polish();
265 m_contentHeightDirty = true;
266 }
267 Q_EMIT headerChanged();
268 }
271QQmlComponent *ListViewWithPageHeader::sectionDelegate() const
273 return m_sectionDelegate;
276void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
278 if (delegate != m_sectionDelegate) {
279 // TODO clean existing sections
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, &QQuickItem::heightChanged, this, &ListViewWithPageHeader::stickyHeaderHeightChanged);
288 // TODO create sections for existing items
290 Q_EMIT sectionDelegateChanged();
291 Q_EMIT stickyHeaderHeightChanged();
292 }
295QString ListViewWithPageHeader::sectionProperty() const
297 return m_sectionProperty;
300void ListViewWithPageHeader::setSectionProperty(const QString &property)
302 if (property != m_sectionProperty) {
303 m_sectionProperty = property;
305 updateWatchedRoles();
307 // TODO recreate sections
309 Q_EMIT sectionPropertyChanged();
310 }
313bool ListViewWithPageHeader::forceNoClip() const
315 return m_forceNoClip;
318void ListViewWithPageHeader::setForceNoClip(bool noClip)
320 if (noClip != m_forceNoClip) {
321 m_forceNoClip = noClip;
322 updateClipItem();
323 Q_EMIT forceNoClipChanged();
324 }
327int ListViewWithPageHeader::stickyHeaderHeight() const
329 return m_topSectionItem ? m_topSectionItem->height() : 0;
332qreal ListViewWithPageHeader::headerItemShownHeight() const
334 return m_headerItemShownHeight;
337int ListViewWithPageHeader::cacheBuffer() const
339 return m_cacheBuffer;
342void ListViewWithPageHeader::setCacheBuffer(int cacheBuffer)
344 if (cacheBuffer < 0) {
345 qmlInfo(this) << "Cannot set a negative cache buffer";
346 return;
347 }
349 if (cacheBuffer != m_cacheBuffer) {
350 m_cacheBuffer = cacheBuffer;
351 Q_EMIT cacheBufferChanged();
352 polish();
353 }
356void ListViewWithPageHeader::positionAtBeginning()
358 if (m_delegateModel->count() <= 0)
359 return;
361 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
362 if (m_firstVisibleIndex != 0) {
363 // TODO This could be optimized by trying to reuse the interesection
364 // of items that may end up intersecting between the existing
365 // m_visibleItems and the items we are creating in the next loop
366 Q_FOREACH(ListItem *item, m_visibleItems)
367 releaseItem(item);
368 m_visibleItems.clear();
369 m_firstVisibleIndex = -1;
371 // Create the item 0, it will be already correctly positioned at createItem()
372 m_clipItem->setY(0);
373 ListItem *item = createItem(0, false);
374 // Create the subsequent items
375 int modelIndex = 1;
376 qreal pos = item->y() + item->height();
377 const qreal bufferTo = height() + m_cacheBuffer;
378 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
379 if (!(item = createItem(modelIndex, false)))
380 break;
381 pos += item->height();
382 ++modelIndex;
383 }
385 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
386 }
387 setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
388 if (m_headerItem) {
389 // TODO This should not be needed and the code that adjust the m_headerItem position
390 // in viewportMoved() should be enough but in some cases we have not found a way to reproduce
391 // yet the code of viewportMoved() fails so here we make sure that at least if we are calling
392 // positionAtBeginning the header item will be correctly positioned
393 m_headerItem->setY(-m_minYExtent);
394 }
397static inline bool uFuzzyCompare(qreal r1, qreal r2)
399 return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
402void ListViewWithPageHeader::showHeader()
404 if (!m_headerItem)
405 return;
407 const auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
408 if (!uFuzzyCompare(to, contentY())) {
409 const bool headerShownByItsOwn = contentY() < m_headerItem->y() + m_headerItem->height();
410 if (headerShownByItsOwn && m_headerItemShownHeight == 0) {
411 // We are not clipping since we are just at the top of the viewport
412 // but because of the showHeader animation we will need to, so
413 // enable the clipping without logically moving the items
414 m_headerItemShownHeight = m_headerItem->y() + m_headerItem->height() - contentY();
415 if (!m_visibleItems.isEmpty()) {
416 updateClipItem();
417 ListItem *firstItem = m_visibleItems.first();
418 firstItem->setY(firstItem->y() - m_headerItemShownHeight);
419 layout();
420 }
421 Q_EMIT headerItemShownHeightChanged();
422 }
423 m_contentYAnimation->setTo(to);
424 contentYAnimationType = ContentYAnimationShowHeader;
425 m_contentYAnimation->start();
426 }
429int ListViewWithPageHeader::firstCreatedIndex() const
431 return m_firstVisibleIndex;
434int ListViewWithPageHeader::createdItemCount() const
436 return m_visibleItems.count();
439QQuickItem *ListViewWithPageHeader::item(int modelIndex) const
441 ListItem *item = itemAtIndex(modelIndex);
442 if (item)
443 return item->m_item;
444 else
445 return nullptr;
448bool ListViewWithPageHeader::maximizeVisibleArea(int modelIndex)
450 ListItem *listItem = itemAtIndex(modelIndex);
451 if (listItem) {
452 return maximizeVisibleArea(listItem, listItem->height());
453 }
455 return false;
458bool ListViewWithPageHeader::maximizeVisibleArea(int modelIndex, int itemHeight)
460 if (itemHeight < 0)
461 return false;
463 ListItem *listItem = itemAtIndex(modelIndex);
464 if (listItem) {
465 return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
466 }
468 return false;
471bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem, int listItemHeight)
473 if (listItem) {
474 layout();
475 const auto listItemY = m_clipItem->y() + listItem->y();
476 if (listItemY > contentY() && listItemY + listItemHeight > contentY() + height()) {
477 // we can scroll the list up to show more stuff
478 const auto to = qMin(listItemY, listItemY + listItemHeight - height());
479 m_contentYAnimation->setTo(to);
480 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
481 m_contentYAnimation->start();
482 } else if ((listItemY < contentY() && listItemY + listItemHeight < contentY() + height()) ||
483 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))
484 {
485 // we can scroll the list down to show more stuff
486 auto realVisibleListItemY = listItemY;
487 if (m_topSectionItem) {
488 // If we are showing the top section sticky item and this item doesn't have a section
489 // item we have to make sure to scroll it a bit more so that it is not underlapping
490 // the top section sticky item
491 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;
492 if (topSectionShown && !listItem->sectionItem()) {
493 realVisibleListItemY -= m_topSectionItem->height();
494 }
495 }
496 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());
497 m_contentYAnimation->setTo(to);
498 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;
499 m_contentYAnimation->start();
500 }
501 return true;
502 }
503 return false;
506qreal ListViewWithPageHeader::minYExtent() const
508// qDebug() << "ListViewWithPageHeader::minYExtent" << m_minYExtent;
509 return m_minYExtent;
512void ListViewWithPageHeader::componentComplete()
514 if (m_delegateModel)
515 m_delegateModel->componentComplete();
517 QQuickFlickable::componentComplete();
519 polish();
522void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
524 // Check we are not being taken down and don't paint anything
525 // TODO Check if we still need this in 5.2
526 // For reproduction just inifnite loop testDash or testDashContent
527 if (!QQmlEngine::contextForObject(this)->parentContext())
528 return;
530 QQuickFlickable::viewportMoved(orient);
531// qDebug() << "ListViewWithPageHeader::viewportMoved" << contentY();
532 const qreal diff = m_previousContentY - contentY();
533 adjustHeader(diff);
534 m_previousContentY = contentY();
535 layout();
536 polish();
539void ListViewWithPageHeader::adjustHeader(qreal diff)
541 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;
542 if (m_headerItem) {
543 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;
544 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {
545 m_headerItem->setHeight(m_headerItem->implicitHeight());
546 // We are going down (but it's not because of the rebound at the end)
547 // (but the header was not shown by it's own position)
548 // or the header is partially shown and we are not doing a maximizeVisibleArea either
549 const bool scrolledUp = m_previousContentY > contentY();
550 const bool notRebounding = qRound(contentY() + height()) < qRound(contentHeight());
551 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();
552 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;
554 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {
555 m_headerItemShownHeight = 0;
556 m_headerItem->setY(-m_minYExtent);
557 } else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0) || m_inContentHeightKeepHeaderShown) {
558 if (maximizeVisibleAreaRunning && diff > 0) {
559 // If we are maximizing and the header was shown, make sure we hide it
560 m_headerItemShownHeight -= diff;
561 } else {
562 m_headerItemShownHeight += diff;
563 }
564 if (uFuzzyCompare(contentY(), -m_minYExtent)) {
565 m_headerItemShownHeight = 0;
566 } else {
567 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
568 }
569 if (m_headerItemShownHeight > 0) {
570 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {
571 m_headerItem->setY(contentY());
572 m_headerItemShownHeight = m_headerItem->height();
573 } else {
574 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
575 }
576 } else {
577 m_headerItem->setY(-m_minYExtent);
578 }
579 }
580 Q_EMIT headerItemShownHeightChanged();
581 } else {
582 // Stick the header item to the top when dragging down
583 m_headerItem->setY(contentY());
584 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
585 }
586 // We will be changing the clip item, need to accomadate for it
587 // otherwise we move the firstItem down/up twice (unless the
588 // show header animation is running, where we want to keep the viewport stable)
589 if (!showHeaderAnimationRunning) {
590 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
591 } else {
592 diff = -diff;
593 }
594 }
595 if (!m_visibleItems.isEmpty()) {
596 updateClipItem();
597 ListItem *firstItem = m_visibleItems.first();
598 firstItem->setY(firstItem->y() + diff);
599 if (showHeaderAnimationRunning) {
600 adjustMinYExtent();
601 }
602 }
605void ListViewWithPageHeader::createDelegateModel()
607 m_delegateModel = new QQmlDelegateModel(qmlContext(this), this);
608 connect(m_delegateModel, &QQmlDelegateModel::createdItem, this, &ListViewWithPageHeader::itemCreated);
609 if (isComponentComplete())
610 m_delegateModel->componentComplete();
611 updateWatchedRoles();
614void ListViewWithPageHeader::refill()
616 if (m_inLayout) {
617 return;
618 }
619 if (!isComponentComplete()) {
620 return;
621 }
623 const qreal from = contentY();
624 const qreal to = from + height();
625 const qreal bufferFrom = from - m_cacheBuffer;
626 const qreal bufferTo = to + m_cacheBuffer;
628 bool added = addVisibleItems(from, to, false);
629 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
630 added |= addVisibleItems(bufferFrom, bufferTo, true);
632 if (added || removed) {
633 m_contentHeightDirty = true;
634 }
637bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)
639 if (!delegate())
640 return false;
642 if (m_delegateModel->count() == 0)
643 return false;
645 ListItem *item;
646// qDebug() << "ListViewWithPageHeader::addVisibleItems" << fillFrom << fillTo << asynchronous;
648 int modelIndex = 0;
649 qreal pos = 0;
650 if (!m_visibleItems.isEmpty()) {
651 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
652 item = m_visibleItems.last();
653 pos = item->y() + item->height() + m_clipItem->y();
654 }
655 bool changed = false;
656// qDebug() << (modelIndex < m_delegateModel->count()) << pos << fillTo;
657 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
658// qDebug() << "refill: append item" << modelIndex << "pos" << pos << "asynchronous" << asynchronous;
659 if (!(item = createItem(modelIndex, asynchronous)))
660 break;
661 pos += item->height();
662 ++modelIndex;
663 changed = true;
664 }
666 modelIndex = 0;
667 pos = 0;
668 if (!m_visibleItems.isEmpty()) {
669 modelIndex = m_firstVisibleIndex - 1;
670 item = m_visibleItems.first();
671 pos = item->y() + m_clipItem->y();
672 }
673 while (modelIndex >= 0 && pos > fillFrom) {
674// qDebug() << "refill: prepend item" << modelIndex << "pos" << pos << "fillFrom" << fillFrom << "asynchronous" << asynchronous;
675 if (!(item = createItem(modelIndex, asynchronous)))
676 break;
677 pos -= item->height();
678 --modelIndex;
679 changed = true;
680 }
682 return changed;
685void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
687 QQuickItem *item = listItem->m_item;
688 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
689 if (flags & QQmlDelegateModel::Destroyed) {
690 item->setParentItem(nullptr);
691 }
692 listItem->sectionItem()->deleteLater();
693 delete listItem;
696void ListViewWithPageHeader::releaseItem(ListItem *listItem)
698 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
699 itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
700 m_itemsToRelease << listItem;
703void ListViewWithPageHeader::updateWatchedRoles()
705 if (m_delegateModel) {
706 QList<QByteArray> roles;
707 if (!m_sectionProperty.isEmpty())
708 roles << m_sectionProperty.toUtf8();
709 m_delegateModel->setWatchedRoles(roles);
710 }
713QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex, bool alreadyInserted)
715 if (!m_sectionDelegate)
716 return nullptr;
718 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
720 if (modelIndex > 0) {
721 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
722 if (section == prevSection)
723 return nullptr;
724 }
725 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
726 // Already inserted items can't steal next section header
727 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
728 if (section == nextSection) {
729 // Steal the section header
730 ListItem *nextItem = itemAtIndex(modelIndex); // Not +1 since not yet inserted into m_visibleItems
731 if (nextItem) {
732 QQuickItem *sectionItem = nextItem->sectionItem();
733 nextItem->setSectionItem(nullptr);
734 return sectionItem;
735 }
736 }
737 }
739 return getSectionItem(section);
742QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText)
744 QQuickItem *sectionItem = nullptr;
746 QQmlContext *creationContext = m_sectionDelegate->creationContext();
747 QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));
748 context->setContextProperty(QLatin1String("section"), sectionText);
749 context->setContextProperty(QLatin1String("delegateIndex"), -1);
750 QObject *nobj = m_sectionDelegate->beginCreate(context);
751 if (nobj) {
752 QQml_setParent_noEvent(context, nobj);
753 sectionItem = qobject_cast<QQuickItem *>(nobj);
754 if (!sectionItem) {
755 delete nobj;
756 } else {
757 sectionItem->setZ(2);
758 QQml_setParent_noEvent(sectionItem, m_clipItem);
759 sectionItem->setParentItem(m_clipItem);
760 }
761 } else {
762 delete context;
763 }
764 m_sectionDelegate->completeCreate();
766 // TODO attach to sectionItem so we can accomodate to it changing its height
768 return sectionItem;
771bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
773// qDebug() << "ListViewWithPageHeader::removeNonVisibleItems" << bufferFrom << bufferTo;
774 // Do not remove items if we are overshooting up or down, since we'll come back
775 // to the "stable" position and delete/create items without any reason
776 if (contentY() < -m_minYExtent) {
777 return false;
778 } else if (contentY() + height() > contentHeight()) {
779 return false;
780 }
781 bool changed = false;
783 bool foundVisible = false;
784 int i = 0;
785 int removedItems = 0;
786 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
787 while (i < m_visibleItems.count()) {
788 ListItem *item = m_visibleItems[i];
789 const qreal pos = item->y() + m_clipItem->y();
790// qDebug() << i << pos << (pos + item->height()) << bufferFrom << bufferTo;
791 if (pos + item->height() < bufferFrom || pos > bufferTo) {
792// qDebug() << "Releasing" << i << (pos + item->height() < bufferFrom) << pos + item->height() << bufferFrom << (pos > bufferTo) << pos << bufferTo;
793 releaseItem(item);
794 m_visibleItems.removeAt(i);
795 changed = true;
796 ++removedItems;
797 } else {
798 if (!foundVisible) {
799 foundVisible = true;
800 const int itemIndex = m_firstVisibleIndex + removedItems + i;
801 m_firstVisibleIndex = itemIndex;
802 }
803 ++i;
804 }
805 }
806 if (!foundVisible) {
807 m_firstVisibleIndex = -1;
808 }
809 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
810 adjustMinYExtent();
811 }
813 return changed;
816ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(int modelIndex, bool asynchronous)
818// qDebug() << "CREATE ITEM" << modelIndex;
819 if (asynchronous && m_asyncRequestedIndex != -1)
820 return nullptr;
822 m_asyncRequestedIndex = -1;
823 QObject* object = m_delegateModel->object(modelIndex, asynchronous);
824 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
825 if (!item) {
826 if (object) {
827 m_delegateModel->release(object);
828 if (!m_delegateValidated) {
829 m_delegateValidated = true;
830 QObject* delegateObj = delegate();
831 qmlInfo(delegateObj ? delegateObj : this) << "Delegate must be of Item type";
832 }
833 } else {
834 m_asyncRequestedIndex = modelIndex;
835 }
836 return 0;
837 } else {
838// qDebug() << "ListViewWithPageHeader::createItem::We have the item" << modelIndex << item;
839 ListItem *listItem = new ListItem;
840 listItem->m_item = item;
841 listItem->setSectionItem(getSectionItem(modelIndex, false /*Not yet inserted into m_visibleItems*/));
842 QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
843 ListItem *prevItem = itemAtIndex(modelIndex - 1);
844 bool lostItem = false; // Is an item that we requested async but because of model changes
845 // it is no longer attached to any of the existing items (has no prev nor next item)
846 // nor is the first item
847 if (prevItem) {
848 listItem->setY(prevItem->y() + prevItem->height());
849 } else {
850 ListItem *currItem = itemAtIndex(modelIndex);
851 if (currItem) {
852 // There's something already in m_visibleItems at out index, meaning this is an insert, so attach to its top
853 listItem->setY(currItem->y() - listItem->height());
854 } else {
855 ListItem *nextItem = itemAtIndex(modelIndex + 1);
856 if (nextItem) {
857 listItem->setY(nextItem->y() - listItem->height());
858 } else if (modelIndex == 0) {
859 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));
860 } else if (!m_visibleItems.isEmpty()) {
861 lostItem = true;
862 }
863 }
864 }
865 if (lostItem) {
866 listItem->setCulled(true);
867 releaseItem(listItem);
868 listItem = nullptr;
869 } else {
870 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
871 if (m_visibleItems.isEmpty()) {
872 m_visibleItems << listItem;
873 } else {
874 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
875 }
876 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
877 m_firstVisibleIndex = modelIndex;
878 polish();
879 }
880 if (listItem->sectionItem()) {
881 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();
882 context->setContextProperty(QLatin1String("delegateIndex"), modelIndex);
883 }
884 adjustMinYExtent();
885 m_contentHeightDirty = true;
886 }
887 return listItem;
888 }
891void ListViewWithPageHeader::itemCreated(int modelIndex, QObject *object)
893 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
894 if (!item) {
895 qWarning() << "ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;
896 return;
897 }
898// qDebug() << "ListViewWithPageHeader::itemCreated" << modelIndex << item;
899 // Check we are not being taken down and don't paint anything
900 // TODO Check if we still need this in 5.2
901 // For reproduction just inifnite loop testDash or testDashContent
902 if (!QQmlEngine::contextForObject(this)->parentContext())
903 return;
905 item->setParentItem(m_clipItem);
906 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
907 context->setContextProperty(QLatin1String("ListViewWithPageHeader"), this);
908 context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
909 if (modelIndex == m_asyncRequestedIndex) {
910 createItem(modelIndex, false);
911 refill();
912 }
915void ListViewWithPageHeader::updateClipItem()
917 m_clipItem->setHeight(height() - m_headerItemShownHeight);
918 m_clipItem->setY(contentY() + m_headerItemShownHeight);
919 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
922void ListViewWithPageHeader::onContentHeightChanged()
924 updateClipItem();
927void ListViewWithPageHeader::onContentWidthChanged()
929 m_clipItem->setWidth(contentItem()->width());
932void ListViewWithPageHeader::onHeightChanged()
934 polish();
938void ListViewWithPageHeader::onModelUpdated(const QQmlChangeSet &changeSet, bool /*reset*/)
940 // TODO Do something with reset
941// qDebug() << "ListViewWithPageHeader::onModelUpdated" << changeSet << reset;
942 const auto oldFirstVisibleIndex = m_firstVisibleIndex;
944 Q_FOREACH(const QQmlChangeSet::Change &remove, changeSet.removes()) {
945// qDebug() << "ListViewWithPageHeader::onModelUpdated Remove" << remove.index << remove.count;
946 if (remove.index + remove.count > m_firstVisibleIndex && remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
947 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
948 // If all the items we are removing are either not created or culled
949 // we have to grow down to avoid viewport changing
950 bool growDown = true;
951 for (int i = 0; growDown && i < remove.count; ++i) {
952 const int modelIndex = remove.index + i;
953 ListItem *item = itemAtIndex(modelIndex);
954 if (item && !item->culled()) {
955 growDown = false;
956 }
957 }
958 for (int i = remove.count - 1; i >= 0; --i) {
959 const int visibleIndex = remove.index + i - m_firstVisibleIndex;
960 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
961 ListItem *item = m_visibleItems[visibleIndex];
962 // Pass the section item down if needed
963 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {
964 ListItem *nextItem = m_visibleItems[visibleIndex + 1];
965 if (!nextItem->sectionItem()) {
966 nextItem->setSectionItem(item->sectionItem());
967 item->setSectionItem(nullptr);
968 }
969 }
970 releaseItem(item);
971 m_visibleItems.removeAt(visibleIndex);
972 }
973 }
974 if (growDown) {
975 adjustMinYExtent();
976 } else if (remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
977 m_visibleItems.first()->setY(oldFirstValidIndexPos);
978 }
979 if (m_visibleItems.isEmpty()) {
980 m_firstVisibleIndex = -1;
981 } else {
982 m_firstVisibleIndex -= qMax(0, m_firstVisibleIndex - remove.index);
983 }
984 } else if (remove.index + remove.count <= m_firstVisibleIndex) {
985 m_firstVisibleIndex -= remove.count;
986 }
987 for (int i = remove.count - 1; i >= 0; --i) {
988 const int modelIndex = remove.index + i;
989 if (modelIndex == m_asyncRequestedIndex) {
990 m_asyncRequestedIndex = -1;
991 } else if (modelIndex < m_asyncRequestedIndex) {
992 m_asyncRequestedIndex--;
993 }
994 }
995 }
997 Q_FOREACH(const QQmlChangeSet::Change &insert, changeSet.inserts()) {
998// qDebug() << "ListViewWithPageHeader::onModelUpdated Insert" << insert.index << insert.count;
999 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
1000 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
1001 if (insertingInValidIndexes || firstItemWithViewOnTop)
1003 // If the items we are adding won't be really visible
1004 // we grow up instead of down to not change the viewport
1005 bool growUp = false;
1006 if (!firstItemWithViewOnTop) {
1007 for (int i = 0; i < m_visibleItems.count(); ++i) {
1008 if (!m_visibleItems[i]->culled()) {
1009 if (insert.index <= m_firstVisibleIndex + i) {
1010 growUp = true;
1012 break;
1017 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1018 for (int i = insert.count - 1; i >= 0; --i) {
1019 const int modelIndex = insert.index + i;
1020 ListItem *item = createItem(modelIndex, false);
1021 if (growUp) {
1022 ListItem *firstItem = m_visibleItems.first();
1023 firstItem->setY(firstItem->y() - item->height());
1025 // Adding an item may break a "same section" chain, so check
1026 // if we need adding a new section item
1027 if (m_sectionDelegate) {
1028 ListItem *nextItem = itemAtIndex(modelIndex + 1);
1029 if (nextItem && !nextItem->sectionItem()) {
1030 nextItem->setSectionItem(getSectionItem(modelIndex + 1, true /* alredy inserted into m_visibleItems*/));
1031 if (growUp && nextItem->sectionItem()) {
1032 ListItem *firstItem = m_visibleItems.first();
1033 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());
1038 if (firstItemWithViewOnTop) {
1039 ListItem *firstItem = m_visibleItems.first();
1040 firstItem->setY(oldFirstValidIndexPos);
1042 adjustMinYExtent();
1043 } else if (insert.index <= m_firstVisibleIndex) {
1044 m_firstVisibleIndex += insert.count;
1047 for (int i = insert.count - 1; i >= 0; --i) {
1048 const int modelIndex = insert.index + i;
1049 if (modelIndex <= m_asyncRequestedIndex) {
1050 m_asyncRequestedIndex++;
1055 Q_FOREACH(const QQmlChangeSet::Change &change, changeSet.changes()) {
1056// qDebug() << "ListViewWithPageHeader::onModelUpdated Change" << change.index << change.count;
1057 for (int i = change.index; i < change.count; ++i) {
1058 ListItem *item = itemAtIndex(i);
1059 if (item && item->sectionItem()) {
1060 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1061 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);
1062 context->setContextProperty(QLatin1String("section"), sectionText);
1067 if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1068 adjustMinYExtent();
1071 for (int i = 0; i < m_visibleItems.count(); ++i) {
1072 ListItem *item = m_visibleItems[i];
1073 if (item->sectionItem()) {
1074 QQmlContext *context = QQmlEngine::contextForObject(item->sectionItem())->parentContext();
1075 context->setContextProperty(QLatin1String("delegateIndex"), m_firstVisibleIndex + i);
1079 layout();
1080 polish();
1081 m_contentHeightDirty = true;
1084void ListViewWithPageHeader::contentYAnimationRunningChanged(bool running)
1086 setInteractive(!running);
1087 if (!running) {
1088 m_contentHeightDirty = true;
1089 polish();
1093void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * /*item*/, const QRectF &newGeometry, const QRectF &oldGeometry)
1095 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1096 if (heightDiff != 0) {
1097 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY() && !m_visibleItems.isEmpty()) {
1098 ListItem *firstItem = m_visibleItems.first();
1099 firstItem->setY(firstItem->y() - heightDiff);
1100 adjustMinYExtent();
1101 layout();
1103 refill();
1104 adjustMinYExtent();
1105 polish();
1106 m_contentHeightDirty = true;
1110void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1112 if (item == m_headerItem) {
1113 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;
1114 if (diff != 0) {
1115 adjustHeader(diff);
1116 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();
1117 layout();
1118 polish();
1119 m_contentHeightDirty = true;
1124void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1126 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1127 if (m_headerItemShownHeight > 0) {
1128 // If the header is shown because of the clip
1129 // Change its size
1130 m_headerItemShownHeight += heightDiff;
1131 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1132 updateClipItem();
1133 adjustMinYExtent();
1134 Q_EMIT headerItemShownHeightChanged();
1135 } else {
1136 if (oldHeaderY + oldHeaderHeight > contentY()) {
1137 // If the header is shown because its position
1138 // Change its size
1139 ListItem *firstItem = m_visibleItems.first();
1140 firstItem->setY(firstItem->y() + heightDiff);
1141 layout();
1142 } else {
1143 // If the header is not on screen, just change the start of the list
1144 // so the viewport is not changed
1145 adjustMinYExtent();
1151void ListViewWithPageHeader::adjustMinYExtent()
1153 if (m_visibleItems.isEmpty()) {
1154 m_minYExtent = 0;
1155 } else {
1156 qreal nonCreatedHeight = 0;
1157 if (m_firstVisibleIndex != 0) {
1158 // Calculate the average height of items to estimate the position of the list start
1159 const int visibleItems = m_visibleItems.count();
1160 qreal visibleItemsHeight = 0;
1161 Q_FOREACH(ListItem *item, m_visibleItems) {
1162 visibleItemsHeight += item->height();
1164 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1165// qDebug() << m_firstVisibleIndex << visibleItemsHeight << visibleItems << nonCreatedHeight;
1167 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);
1168 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;
1169 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
1170 m_minYExtent = 0;
1171 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);
1176ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(int modelIndex) const
1178 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1179 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1180 return m_visibleItems[visibleIndexedModelIndex];
1182 return nullptr;
1185void ListViewWithPageHeader::layout()
1187 if (m_inLayout)
1188 return;
1190 m_inLayout = true;
1191 if (!m_visibleItems.isEmpty()) {
1192 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1193 const qreal visibleTo = contentY() + height() - m_clipItem->y();
1195 qreal pos = m_visibleItems.first()->y();
1197// qDebug() << "ListViewWithPageHeader::layout Updating positions and heights. contentY" << contentY() << "minYExtent" << minYExtent();
1198 int firstReallyVisibleItem = -1;
1199 int modelIndex = m_firstVisibleIndex;
1200 Q_FOREACH(ListItem *item, m_visibleItems) {
1201 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;
1202 item->setCulled(cull);
1203 item->setY(pos);
1204 if (!cull && firstReallyVisibleItem == -1) {
1205 firstReallyVisibleItem = modelIndex;
1206 if (m_topSectionItem) {
1207 // Positing the top section sticky item is a two step process
1208 // First we set it either we cull it (because it doesn't need to be sticked to the top)
1209 // or stick it to the top
1210 // Then after the loop we'll make sure that if there's another section just below it
1211 // pushed the sticky section up to make it disappear
1212 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1213 bool showStickySectionItem;
1214 // We need to show the "top section sticky item" when the position at the "top" of the
1215 // viewport is bigger than the start of the position of the first visible item
1216 // i.e. the first visible item starts before the viewport, or when the first
1217 // visible item starts just at the viewport start and it does not have its own section item
1218 if (topSectionStickPos > pos) {
1219 showStickySectionItem = true;
1220 } else if (topSectionStickPos == pos) {
1221 showStickySectionItem = !item->sectionItem();
1222 } else {
1223 showStickySectionItem = false;
1225 if (!showStickySectionItem) {
1226 QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
1227 if (item->sectionItem()) {
1228 // This seems it should happen since why would we cull the top section
1229 // if the first visible item has no section header? This only happens briefly
1230 // when increasing the height of a list that is at the bottom, the m_topSectionItem
1231 // gets shown shortly in the next polish call
1232 QQuickItemPrivate::get(item->sectionItem())->setCulled(false);
1234 } else {
1235 // Update the top sticky section header
1236 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1237 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1238 context->setContextProperty(QLatin1String("section"), section);
1240 QQuickItemPrivate::get(m_topSectionItem)->setCulled(false);
1241 m_topSectionItem->setY(topSectionStickPos);
1242 int delegateIndex = modelIndex;
1243 // Look for the first index with this section text
1244 while (delegateIndex > 0) {
1245 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);
1246 if (prevSection != section)
1247 break;
1248 delegateIndex--;
1250 context->setContextProperty(QLatin1String("delegateIndex"), delegateIndex);
1251 if (item->sectionItem()) {
1252 QQuickItemPrivate::get(item->sectionItem())->setCulled(true);
1257 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1258 const qreal clipFrom = visibleFrom + (!item->sectionItem() && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1259 if (!cull && pos < clipFrom) {
1260 context->setContextProperty(QLatin1String("heightToClip"), clipFrom - pos);
1261 } else {
1262 context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
1264// qDebug() << "ListViewWithPageHeader::layout" << item->m_item;
1265 pos += item->height();
1266 ++modelIndex;
1269 // Second step of section sticky item positioning
1270 // Look at the next section header, check if it's pushing up the sticky one
1271 if (m_topSectionItem) {
1272 if (firstReallyVisibleItem >= 0) {
1273 for (int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1274 ListItem *item = m_visibleItems[i];
1275 if (item->sectionItem()) {
1276 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1277 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1279 break;
1285 m_inLayout = false;
1288void ListViewWithPageHeader::updatePolish()
1290 // Check we are not being taken down and don't paint anything
1291 // TODO Check if we still need this in 5.2
1292 // For reproduction just inifnite loop testDash or testDashContent
1293 if (!QQmlEngine::contextForObject(this)->parentContext())
1294 return;
1296 Q_FOREACH(ListItem *item, m_itemsToRelease)
1297 reallyReleaseItem(item);
1298 m_itemsToRelease.clear();
1300 if (!model())
1301 return;
1303 layout();
1305 refill();
1307 if (m_contentHeightDirty) {
1308 qreal contentHeight;
1309 if (m_visibleItems.isEmpty()) {
1310 contentHeight = m_headerItem ? m_headerItem->height() : 0;
1311 } else {
1312 const int modelCount = model()->rowCount();
1313 const int visibleItems = m_visibleItems.count();
1314 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1315 qreal nonCreatedHeight = 0;
1316 if (lastValidIndex != modelCount - 1) {
1317 const int visibleItems = m_visibleItems.count();
1318 qreal visibleItemsHeight = 0;
1319 Q_FOREACH(ListItem *item, m_visibleItems) {
1320 visibleItemsHeight += item->height();
1322 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1323 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1325 ListItem *item = m_visibleItems.last();
1326 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1327 if (m_firstVisibleIndex != 0) {
1328 // Make sure that if we are shrinking we tell the view we still fit
1329 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1333 m_contentHeightDirty = false;
1334 adjustMinYExtent();
1335 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1336 setContentHeight(contentHeight);
1337 m_inContentHeightKeepHeaderShown = false;
1341#include "moc_listviewwithpageheader.cpp"